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

我想使用C#检查字符串值是否包含字符串数组中的单词。比如说,

string stringToCheck = "text1text2text3";

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

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

}

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

以下是如何检查的：

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

这将检查

stringToCheck

是否包含

stringArray

中的任何一个子字符串。如果要确保它包含所有子字符串，请将

Any

更改为

all

：

if(stringArray.All(stringToCheck.Contains))

---

以下是您如何做到这一点：

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

---

更新：可能您正在寻找更好的解决方案。。请参考以下@Anton Gogolev使用LINQ的回答。

类似的内容：

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

stringToCheck=“text1text2text3”；
字符串[]stringArray=新字符串[]{“text1”}；
如果（Array.Exists）（stringArray，（谓词）委托（strings）{
返回stringToCheck.IndexOf（s，StringComparison.OrdinalIgnoreCase）>-1；}）{
控制台。WriteLine（“找到！”）；
}

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

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

尝试：

---

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

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

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

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

String[]val={“helloword1”、“橙”、“葡萄”、“梨”}；
表达式someFieldFilter=i=>true；
someFieldFilter=i=>val.Any（s=>i.someField.Contains）；

使用Linq和方法组将是实现这一点的最快和更紧凑的方法

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

试试这个： 不需要使用LINQ

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

---

您也可以按照Anton Gogolev的建议，检查

stringArray1

中的任何项目是否与

stringArray2

中的任何项目相匹配：

if(stringArray1.Any(stringArray2.Contains))

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

if(stringArray1.All(stringArray2.Contains))

public bool ContainAnyOf（字符串字，字符串[]数组）
{
for（int i=0；i

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

如果要比较两个数组，它们将以分号分隔，但最后一个值后面不会有分号。如果将分号附加到数组的字符串形式（即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) { 
    // ....
}

---

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

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

如果搜索的字符串与数组“行”的任何元素匹配，则“查找”将设置为true。

请尝试此操作

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

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

它将返回您要查找的文本的第一个关联行。

只需使用linq方法：

stringArray.Contains(stringToCheck)

---

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

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

---

<> > <代码> String数组包含大量不同长度的字符串，请考虑使用A来存储和搜索字符串数组。

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

如果

stringArray

中的所有字符串长度相同，则最好使用

HashSet

而不是

Trie

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

publicstaticboolcontainsany（此字符串stringToCheck，IEnumerable stringArray）
{
int stringLength=stringArray.First（）.Length；
HashSet stringSet=新的HashSet（stringArray）；
对于（int i=0；i

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

---

Join（“，”，数组）.Contains（值+“，”）

最简单、最简单的方法

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

---

演示了三种选择。我认为第三个最简洁

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

---

试试这个，不需要循环

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

}

stringToCheck=“text1”；
List stringList=新列表（）{“text1”、“someothertext”、“etc…”；
if（stringList.Exists（o=>stringToCheck.Contains（o）））
{
}

您可以定义自己的

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

要完成上述答案，请勾选“对于IgnoreCase使用：

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

就我而言，上述答案并不适用。我正在检查数组中的字符串并将其指定给布尔值。我修改了@Anton Gogolev的答案，删除了
Any（）
方法，并将
stringToCheck
放在
Contains（）方法中

bool = stringArray.Contains(stringToCheck);

使用或使用类的方法：

大多数解决方案都是正确的，但如果需要不区分大小写的检查值

using System.Linq;
...
string stringToCheck = "text1text2text3";
string[] stringArray = { "text1", "someothertext"};

if(stringArray.Any(a=> String.Equals(a, stringToCheck, StringComparison.InvariantCultureIgnoreCase)) )
{ 
   //contains
}

if (stringArray.Any(w=> w.IndexOf(stringToCheck, StringComparison.InvariantCultureIgnoreCase)>=0))
{
   //contains
}

您也可以尝试此解决方案

string[] nonSupportedExt = { ".3gp", ".avi", ".opus", ".wma", ".wav", ".m4a", ".ac3", ".aac", ".aiff" };
        
bool valid = Array.Exists(nonSupportedExt,E => E == ".Aac".ToLower());

给自己的提示：linq是惊人的，linq是惊人的，linq是惊人的！必须“开始使用linq。@通过.NET 2.0上的LinqBridge可以使用Spooks linq To对象（在答案的字符串检查中使用）大小写不变性如何处理？@Offler这将是
stringArray.Any（s=>s.IndexOf（stringToCheck，StringComparison.CurrentCultureIgnoreCase）>-1）
如何获取数组中匹配的项？谢谢，我将您的代码修改为：if（stringToCheck.Contains（s）），它起了作用。我修改了if（stringArray.Contains（stringToCheck）），效果很好，谢谢。不要使用此答案，请使用LINQ而不是代替。对在字符串数组上看不到Contains方法的人，请注意：检查您是否有“使用System.Linq；“代码文件中的命名空间：）Linq在旧式软件中并不总是可用。这将设置
Text=“matched”
的次数与
stringToCheck
包含
stringArray
的子字符串的次数相同。您可能希望在分配后放置
中断
或
返回
string stringToCheck = "text1";
List<string> stringList = new List<string>() { "text1", "someothertext", "etc.." };
if (stringList.Exists(o => stringToCheck.Contains(o)))
{

}

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

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

bool = stringArray.Contains(stringToCheck);

stringArray.ToList().Contains(stringToCheck)

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

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

using System.Linq;
...
string stringToCheck = "text1text2text3";
string[] stringArray = { "text1", "someothertext"};

if(stringArray.Any(a=> String.Equals(a, stringToCheck, StringComparison.InvariantCultureIgnoreCase)) )
{ 
   //contains
}

if (stringArray.Any(w=> w.IndexOf(stringToCheck, StringComparison.InvariantCultureIgnoreCase)>=0))
{
   //contains
}

string[] nonSupportedExt = { ".3gp", ".avi", ".opus", ".wma", ".wav", ".m4a", ".ac3", ".aac", ".aiff" };
        
bool valid = Array.Exists(nonSupportedExt,E => E == ".Aac".ToLower());