Tôi muốn sử dụng C # để kiểm tra xem giá trị chuỗi có chứa một từ trong mảng chuỗi không. Ví dụ,

string stringToCheck = "text1text2text3";

string[] stringArray = { "text1", "someothertext", etc... };

if(stringToCheck.contains stringArray) //one of the items?
{

}

Làm cách nào để kiểm tra xem giá trị chuỗi cho 'stringToCheck' có chứa một từ trong mảng không?

Đây là cách bạn có thể làm điều đó:

string stringToCheck = "text1";
string[] stringArray = { "text1", "testtest", "test1test2", "test2text1" };
foreach (string x in stringArray)
{
    if (stringToCheck.Contains(x))
    {
        // Process...
    }
}

CẬP NHẬT: Có thể bạn đang tìm kiếm một giải pháp tốt hơn .. tham khảo câu trả lời của @Anton Gogolev dưới đây sử dụng LINQ.

Đây là cách thực hiện:

if(stringArray.Any(stringToCheck.Contains))
/* or a bit longer: (stringArray.Any(s => stringToCheck.Contains(s))) */

Điều này kiểm tra nếu stringToCheckcó chứa bất kỳ một trong các chuỗi con từ stringArray. Nếu bạn muốn đảm bảo rằng nó chứa tất cả các chuỗi con, hãy đổi Anythành All:

if(stringArray.All(stringToCheck.Contains))

Thử cái này:

Không cần sử dụng LINQ

if (Array.IndexOf(array, Value) >= 0)
{
    //Your stuff goes here
}

Chỉ cần sử dụng phương pháp linq:

stringArray.Contains(stringToCheck)

Cách dễ nhất và mẫu.

  bool bol=Array.Exists(stringarray,E => E == stringtocheck);

string strName = "vernie";
string[] strNamesArray = { "roger", "vernie", "joel" };

if (strNamesArray.Any(x => x == strName))
{
   // do some action here if true...
}

Một cái gì đó như thế này có lẽ:

string stringToCheck = "text1text2text3";
string[] stringArray = new string[] { "text1" };
if (Array.Exists<string>(stringArray, (Predicate<string>)delegate(string s) { 
    return stringToCheck.IndexOf(s, StringComparison.OrdinalIgnoreCase) > -1; })) {
    Console.WriteLine("Found!");
}

Sử dụng Linq và nhóm phương pháp sẽ là cách nhanh nhất và gọn hơn để thực hiện việc này.

var arrayA = new[] {"element1", "element2"};
var arrayB = new[] {"element2", "element3"};
if (arrayB.Any(arrayA.Contains)) return true;

Bạn có thể định nghĩa của riêng bạn string.ContainsAny()và string.ContainsAll()phương pháp. Như một phần thưởng, tôi thậm chí đã ném vào một string.Contains()phương pháp cho phép so sánh không phân biệt chữ hoa chữ thường, v.v.

public static class Extensions
{
    public static bool Contains(this string source, string value, StringComparison comp)
    {
        return source.IndexOf(value, comp) > -1;
    }

    public static bool ContainsAny(this string source, IEnumerable<string> values, StringComparison comp = StringComparison.CurrentCulture)
    {
        return values.Any(value => source.Contains(value, comp));
    }

    public static bool ContainsAll(this string source, IEnumerable<string> values, StringComparison comp = StringComparison.CurrentCulture)
    {
        return values.All(value => source.Contains(value, comp));
    }
}

Bạn có thể kiểm tra những điều này với mã sau đây:

    public static void TestExtensions()
    {
        string[] searchTerms = { "FOO", "BAR" };
        string[] documents = {
            "Hello foo bar",
            "Hello foo",
            "Hello"
        };

        foreach (var document in documents)
        {
            Console.WriteLine("Testing: {0}", document);
            Console.WriteLine("ContainsAny: {0}", document.ContainsAny(searchTerms, StringComparison.OrdinalIgnoreCase));
            Console.WriteLine("ContainsAll: {0}", document.ContainsAll(searchTerms, StringComparison.OrdinalIgnoreCase));
            Console.WriteLine();
        }
    }

Tôi sử dụng như sau trong một ứng dụng giao diện điều khiển để kiểm tra các đối số

var sendmail = args.Any( o => o.ToLower() == "/sendmail=true");

Tôi sẽ sử dụng Linq nhưng nó vẫn có thể được thực hiện thông qua:

new[] {"text1", "text2", "etc"}.Contains(ItemToFind);

Thử:

String[] val = { "helloword1", "orange", "grape", "pear" };
String sep = "";
string stringToCheck = "word1";

bool match = String.Join(sep,val).Contains(stringToCheck);
bool anothermatch = val.Any(s => s.Contains(stringToCheck));

Bạn cũng có thể làm điều tương tự như Anton Gogolev gợi ý để kiểm tra xem bất kỳ mục nào trong stringArray1phù hợp với bất kỳ mục trong stringArray2:

if(stringArray1.Any(stringArray2.Contains))

Và tương tự, tất cả các mục trong chuỗiArray1 khớp với tất cả các mục trong chuỗiArray2:

if(stringArray1.All(stringArray2.Contains))

stringArray.ToList().Contains(stringToCheck)

hãy thử điều này, ở đây ví dụ: Để kiểm tra xem trường có chứa bất kỳ từ nào trong mảng không. Để kiểm tra xem trường (someField) có chứa bất kỳ từ nào trong mảng không.

String[] val = { "helloword1", "orange", "grape", "pear" };   

Expression<Func<Item, bool>> someFieldFilter = i => true;

someFieldFilter = i => val.Any(s => i.someField.Contains(s));

public bool ContainAnyOf(string word, string[] array) 
    {
        for (int i = 0; i < array.Length; i++)
        {
            if (word.Contains(array[i]))
            {
                return true;
            }
        }
        return false;
    }

Tôi đã sử dụng một phương thức tương tự như IndexOf của Maitrey684 và vòng lặp foreach của Theomax để tạo ra điều này. (Lưu ý: 3 dòng "chuỗi" đầu tiên chỉ là một ví dụ về cách bạn có thể tạo một mảng và đưa nó vào định dạng phù hợp).

Nếu bạn muốn so sánh 2 mảng, chúng sẽ được phân cách bằng dấu hai chấm, nhưng giá trị cuối cùng sẽ không có một mảng sau nó. Nếu bạn nối một dấu chấm phẩy vào dạng chuỗi của mảng (tức là a; b; c trở thành a; b; c;), bạn có thể khớp với "x;" bất kể nó ở vị trí nào:

bool found = false;
string someString = "a-b-c";
string[] arrString = someString.Split('-');
string myStringArray = arrString.ToString() + ";";

foreach (string s in otherArray)
{
    if (myStringArray.IndexOf(s + ";") != -1) {
       found = true;
       break;
    }
}

if (found == true) { 
    // ....
}

string [] lines = {"text1", "text2", "etc"};

bool bFound = lines.Any(x => x == "Your string to be searched");

bFound đặt thành true nếu chuỗi tìm kiếm được khớp với bất kỳ phần tử nào của mảng 'dòng'.

Thử cái này

string stringToCheck = "text1text2text3";
string[] stringArray = new string[] { "text1" };

var t = lines.ToList().Find(c => c.Contains(stringToCheck));

Nó sẽ trả về cho bạn dòng với tỷ lệ đầu tiên của văn bản mà bạn đang tìm kiếm.

Nếu stringArraychứa một số lượng lớn các chuỗi có độ dài khác nhau, hãy xem xét sử dụng Trie để lưu trữ và tìm kiếm mảng chuỗi.

public static class Extensions
{
    public static bool ContainsAny(this string stringToCheck, IEnumerable<string> stringArray)
    {
        Trie trie = new Trie(stringArray);
        for (int i = 0; i < stringToCheck.Length; ++i)
        {
            if (trie.MatchesPrefix(stringToCheck.Substring(i)))
            {
                return true;
            }
        }

        return false;
    }
}

Đây là việc thực hiện của Trielớp

public class Trie
{
    public Trie(IEnumerable<string> words)
    {
        Root = new Node { Letter = '\0' };
        foreach (string word in words)
        {
            this.Insert(word);
        }
    }

    public bool MatchesPrefix(string sentence)
    {
        if (sentence == null)
        {
            return false;
        }

        Node current = Root;
        foreach (char letter in sentence)
        {
            if (current.Links.ContainsKey(letter))
            {
                current = current.Links[letter];
                if (current.IsWord)
                {
                    return true;
                }
            }
            else
            {
                return false;
            }
        }

        return false;
    }

    private void Insert(string word)
    {
        if (word == null)
        {
            throw new ArgumentNullException();
        }

        Node current = Root;
        foreach (char letter in word)
        {
            if (current.Links.ContainsKey(letter))
            {
                current = current.Links[letter];
            }
            else
            {
                Node newNode = new Node { Letter = letter };
                current.Links.Add(letter, newNode);
                current = newNode;
            }
        }

        current.IsWord = true;
    }

    private class Node
    {
        public char Letter;
        public SortedList<char, Node> Links = new SortedList<char, Node>();
        public bool IsWord;
    }

    private Node Root;
}

Nếu tất cả các chuỗi stringArraycó cùng độ dài, bạn sẽ tốt hơn nếu chỉ sử dụng HashSetthay vì mộtTrie

public static bool ContainsAny(this string stringToCheck, IEnumerable<string> stringArray)
{
    int stringLength = stringArray.First().Length;
    HashSet<string> stringSet = new HashSet<string>(stringArray);
    for (int i = 0; i < stringToCheck.Length - stringLength; ++i)
    {
        if (stringSet.Contains(stringToCheck.Substring(i, stringLength)))
        {
            return true;
        }
    }

    return false;
}

Giải pháp đơn giản, không yêu cầu linq bất kỳ

String.Join (",", mảng) .Contains (Giá trị + ",");

int result = Array.BinarySearch(list.ToArray(), typedString, StringComparer.OrdinalIgnoreCase);

Hãy thử điều này, không cần một vòng lặp ..

string stringToCheck = "text1";
List<string> stringList = new List<string>() { "text1", "someothertext", "etc.." };
if (stringList.Exists(o => stringToCheck.Contains(o)))
{

}

Để hoàn thành các câu trả lời trên, đối với IgnoreCase, hãy sử dụng:

stringArray.Any(s => stringToCheck.IndexOf(s, StringComparison.CurrentCultureIgnoreCase) > -1)

Đối với trường hợp của tôi, các câu trả lời trên không hoạt động. Tôi đã kiểm tra một chuỗi trong một mảng và gán nó cho một giá trị boolean. Tôi đã sửa đổi câu trả lời của @Anton Gogolev và xóa Any()phương thức và đặt phương thức stringToCheckbên trong Contains().

bool = stringArray.Contains(stringToCheck);

Sử dụng các phương thức Find hoặc Find Index của lớp Array :

if(Array.Find(stringArray, stringToCheck.Contains) != null) 
{ 
}

if(Array.FindIndex(stringArray, stringToCheck.Contains) != -1) 
{ 
}

Tôi đã sử dụng đoạn mã sau để kiểm tra xem chuỗi có chứa bất kỳ mục nào trong mảng chuỗi không:

foreach (string s in stringArray)
{
    if (s != "")
    {
        if (stringToCheck.Contains(s))
        {
            Text = "matched";
        }
    }
}

Ba lựa chọn thể hiện. Tôi thích tìm thứ ba là ngắn gọn nhất.

class Program {
    static void Main(string[] args) {
    string req = "PUT";
    if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) {
        Console.WriteLine("one.1.A");  // IS TRUE
    }
    req = "XPUT";
    if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) {
        Console.WriteLine("one.1.B"); // IS TRUE
    }
    req = "PUTX";
    if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) {
        Console.WriteLine("one.1.C");  // IS TRUE
    }
    req = "UT";
    if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) {
        Console.WriteLine("one.1.D"); // false
    }
    req = "PU";
    if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) {
        Console.WriteLine("one.1.E"); // false
    }
    req = "POST";
    if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) {
        Console.WriteLine("two.1.A"); // IS TRUE
    }
    req = "ASD";
    if ((new string[] {"PUT", "POST"}).Any(s => req.Contains(s))) {
        Console.WriteLine("three.1.A");  // false
    }


    Console.WriteLine("-----");
    req = "PUT";
    if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0)  {
        Console.WriteLine("one.2.A"); // IS TRUE
    }
    req = "XPUT";
    if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0)  {
        Console.WriteLine("one.2.B"); // false
    }
    req = "PUTX";
    if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0)  {
        Console.WriteLine("one.2.C"); // false
    }
    req = "UT";
    if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0)  {
        Console.WriteLine("one.2.D"); // false
    }
    req = "PU";
    if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0)  {
        Console.WriteLine("one.2.E"); // false
    }
    req = "POST";
    if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0)  {
        Console.WriteLine("two.2.A");  // IS TRUE
    }
    req = "ASD";
    if (Array.IndexOf((new string[] {"PUT", "POST"}), req) >= 0)  {
        Console.WriteLine("three.2.A");  // false
    }

    Console.WriteLine("-----");
    req = "PUT";
    if ((new string[] {"PUT", "POST"}.Contains(req)))  {
        Console.WriteLine("one.3.A"); // IS TRUE
    }
    req = "XPUT";
    if ((new string[] {"PUT", "POST"}.Contains(req)))  {
        Console.WriteLine("one.3.B");  // false
    }
    req = "PUTX";
    if ((new string[] {"PUT", "POST"}.Contains(req)))  {
        Console.WriteLine("one.3.C");  // false
    }
    req = "UT";
    if ((new string[] {"PUT", "POST"}.Contains(req)))  {
        Console.WriteLine("one.3.D");  // false
    }
    req = "PU";
    if ((new string[] {"PUT", "POST"}.Contains(req)))  {
        Console.WriteLine("one.3.E");  // false
    }
    req = "POST";
    if ((new string[] {"PUT", "POST"}.Contains(req)))  {
        Console.WriteLine("two.3.A");  // IS TRUE
    }
    req = "ASD";
    if ((new string[] {"PUT", "POST"}.Contains(req)))  {
        Console.WriteLine("three.3.A");  // false
    }

    Console.ReadKey();
    }
}