290

我想使用C＃检查字符串值是否在字符串数组中包含单词。例如，

string stringToCheck = "text1text2text3";

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

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

}

如何检查'stringToCheck'的字符串值在数组中是否包含单词？

c# arrays string search

— Theomax
source

1

此博客基准测试的许多技术，如果一个字符串包含字符串：blogs.davelozinski.com/curiousconsultant/...

— 罗伯特·哈维

145

您可以按照以下方法进行操作：

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

更新：可能是您正在寻找更好的解决方案。.请参阅下面的@Anton Gogolev的答案，该答案使用了LINQ。

— 阿卜杜勒·拉奥夫（Abdel Raoof）
source

3

谢谢，我将您的代码修改为：if（stringToCheck.Contains（s））并成功。

— Theomax

5

我做了if（stringArray.Contains（stringToCheck）），它很好用，谢谢。

— 塔马拉JQ

68

不要使用此答案，而应使用LINQ

— AlexC 2012年

11

给那些在字符串数组上看不到Contains方法的人的几点说明：检查是否有“ using System.Linq;”。代码文件中的命名空间:)

— Sudhanshu Mishra'4

5

Linq并非始终在旧版软件中可用。

— 威廉莫里森

841

就是这样：

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

这将检查是否stringToCheck包含来自的子字符串中的任何一个stringArray。如果要确保它包含所有子字符串，请更改Any为All：

if(stringArray.All(stringToCheck.Contains))

— 安东·戈戈列夫（Anton Gogolev）
source

115

自我注意：linq很棒，linq很棒，linq很棒！要开始使用linq。

— Fredrik Johansson，2010年

2

可以通过.NET 2.0上的LinqBridge

— David Rettenbacher

1

大小写不变怎么办？

— Offler 2013年

14

@Offler那是stringArray.Any(s => s.IndexOf(stringToCheck, StringComparison.CurrentCultureIgnoreCase) > -1)

— Anton Gogolev

2

如何获取数组中匹配的项？

— ibubi

44

尝试这个：

无需使用LINQ

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

— 梅特里684
source

真好！Linq可能比Array.IndexOf有什么好处？

— Heckflosse_230

21

这根本解决不了这个问题。IndexOf告诉您数组是否包含与字符串完全匹配的字符串，最初的问题是字符串是否包含由Linq轻松处理的字符串数组之一。

— NetMage 2014年

我知道这条评论很晚，但对于那些不知道的人，字符串是一个字符数组，因此字符串类型确实包含IndexOf方法...因此@NetMage是一种可能的解决方案。

— Blacky Wolf

3

@Blacky Wolf，你读过这个问题吗？Array.IndexOf告诉您数组是否包含值，OP希望知道值是否包含数组的任何成员，与该答案完全相反。您可以在Linq中使用String.IndexOf：stringArray.Any(w => stringToCheck.IndexOf(w) >= 0)但是使用String.Contains的Linq答案更有意义，因为这正是所要的。

— NetMage 2016年

40

只需使用linq方法：

stringArray.Contains(stringToCheck)

— 莱戈拉斯21
source

4

请注意，Contains是一种扩展方法，您需要做using System.Linq;

— isHuman

11

这个答案是从问题倒过来的。

— NetMage 2016年

1

这个答案是如何被如此多次评价的？提出问题后的5年，解决方案基本上与提出问题的方向相反。

— Fus Ro Dah

1

也许只是反转变量名就可以了吗？

— 让·弗朗索瓦·法布尔

8

最简单的示例方式。

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

— 泽
source

更好的是stringarray.Exists（实体=>实体== stringtocheck）

— MarcelGrüger2016年

我认为您不能直接从字符串数组调用存在方法.Exists方法可以直接用于list <T>。因此应该对字符串数组使用静态方法array.exist <T>。在这里=> msdn.microsoft.com/zh-我们/图书馆/yw84x8be(v=vs.110).aspx

— Jze 2016年

6

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

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

— 韦妮·南卡（Vernie Namca）
source

2

我不认为这是问题的所在。

— 庞

5

大概是这样的：

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!");
}

— 弗雷德里克·约翰逊
source

这是一个更好的解决方案，因为它是针对列表中单词的子字符串检查，而不是精确匹配检查。

— Roy

很好的答案，但是哇，即使没有Linq，与现代C＃相比也很难阅读。同样，它String.Contains可能比String.IndexOf除非您不想忽略大小写要好，因为Microsoft忘记了两个参数，String.Contains您必须编写自己的参数。考虑：Array.Exists(stringArray, s => stringToCheck.IndexOf(s, StringComparison.OrdinalIgnoreCase) > -1)

— NetMage '16

3

使用Linq和method group将是最快，更紧凑的方法。

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

— 郑俊
source

3

您可以定义自己的string.ContainsAny()和string.ContainsAll()方法。另外，我什至抛出了string.Contains()一种允许不区分大小写的比较的方法，等等。

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));
    }
}

您可以使用以下代码进行测试：

    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();
        }
    }

— 凯尔·德莱尼（Kyle Delaney）
source

2

我在控制台应用程序中使用以下命令检查参数

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

— 巴特伯克哈特
source

2

我会使用Linq，但仍可以通过以下方式完成：

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

— 多云大理石
source

1

尝试：

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));

— 瓦尔科
source

1

你也可以做同样的事情，安东Gogolev建议检查是否任何项目在stringArray1比赛的任何项目在stringArray2：

if(stringArray1.Any(stringArray2.Contains))

同样，stringArray1中的所有项目都与stringArray2中的所有项目匹配：

if(stringArray1.All(stringArray2.Contains))

— Scotty.NET
source

1

stringArray.ToList().Contains(stringToCheck)

— 克里斯特·卡尔森
source

0

试试这个，这里是示例：检查字段是否包含数组中的任何单词。检查字段（someField）是否包含数组中的任何单词。

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

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

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

— 维杰
source

0

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

— 仲久
source

0

我使用了与Maitrey684的IndexOf和Theomax的foreach循环类似的方法来创建它。（注意：前3个“字符串”行只是如何创建数组并将其转换为正确格式的示例）。

如果要比较2个数组，它们将以分号分隔，但最后一个值后面将没有一个。如果将分号附加到数组的字符串形式（即a; b; c变为a; b; c;），则可以使用“ x;”进行匹配无论处于什么位置：

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) { 
    // ....
}

— Vapcguy
source

0

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

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

如果搜索到的字符串与数组“ lines”的任何元素匹配，则bFound设置为true。

— Pabitra Dash
source

0

尝试这个

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

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

它将向您返回您要查找的文本的第一个匹配项的行。

— 费尔南多·查韦斯
source

0

如果stringArray包含大量不同长度的字符串，请考虑使用Trie来存储和搜索字符串数组。

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;
    }
}

这是Trie该类的实现

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;
}

如果输入的所有字符串stringArray都具有相同的长度，则最好使用a HashSet而不是aTrie

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;
}

— tcb
source

0

简单的解决方案，不需要linq

String.Join（“，”，array）.Contains（Value +“，”）;

— 用户名
source

2

如果数组中的值之一包含分隔符怎么办？

— Tyler Benzing '16

0

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

— 阿米特·贾（Amit Jha）
source

0

试试这个，不需要循环。

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

}

— Amjad Abu Saa
source

0

要完成上述答案，请为IgnoreCase检查使用：

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

— 阴暗的西汉
source

有什么办法也可以获取比赛的索引吗？谢谢。

— SI 8

0

就我而言，上述答案无效。我正在检查数组中的字符串，并将其分配给布尔值。我修改了@Anton Gogolev的答案，并删除了Any()方法，并将其stringToCheck放入Contains()方法内部。

bool = stringArray.Contains(stringToCheck);

— 马修·米兰达（Matthew Miranda）
source

0

使用Array类的Find或FindIndex方法：

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

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

— 安德烈·托尔斯泰
source

-1

我使用以下代码检查字符串是否包含字符串数组中的任何项目：

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

— Theomax
source

3

设置Text = "matched"次数stringToCheck包含的子字符串一样多stringArray。您可能要在作业后加上break或return。

— 高高的拱门

-1

演示了三个选项。我更喜欢第三种方法。

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();
    }
}

— 史蒂夫
source

您的后两个选项甚至在第一个选项中都做不到相同的事情。

— 凯尔·德莱尼

使用C＃检查字符串是否在字符串数组中包含字符串

尝试这个：