如何检查一个字符串是否包含任何一些字符串

Question

我想检查一个字符串是否包含“a”或“b”或“c”，在C＃中。 我要寻找一个更好的解决方案比使用

if (s.contains("a")||s.contains("b")||s.contains("c")) 

Answer 1

如果您正在寻找单个字符，你可以使用String.IndexOfAny()。

如果你想要任意字符串，那么我不知道.NET方法来实现“直接”，虽然正则表达式可以工作。

Answer 2

嘛，总是有这样的：

public static bool ContainsAny(this string haystack, params string[] needles) 
{ 
    foreach (string needle in needles) 
    { 
     if (haystack.Contains(needle)) 
      return true; 
    } 

    return false; 
} 

用法：

bool anyLuck = s.ContainsAny("a", "b", "c"); 

没有什么回事，以配合您的||链的性能然而，比较。

Answer 3

你可以用正则表达式

string s; 
Regex r = new Regex ("a|b|c"); 
bool containsAny = r.IsMatch (s); 

Answer 4

尝试你可以使用Regular Expressions

if(System.Text.RegularExpressions.IsMatch("a|b|c")) 

Answer 5

这里的LINQ解决方案，它几乎是相同的，但更多的可扩展性：

new[] { "a", "b", "c" }.Any(c => s.Contains(c)) 

Answer 6

作为字符串是字符的集合，你可以对它们使用LINQ扩展方法：

if (s.Any(c => c == 'a' || c == 'b' || c == 'c')) ... 

这将扫描一次字符串并在第一次出现时停止，而不是为每个字符扫描一次字符串，直到找到匹配。

这也可以被用于任何你喜欢的表情，例如用于字符范围检查：

if (s.Any(c => c >= 'a' && c <= 'c')) ... 

Answer 7

// Nice method's name, @Dan Tao 

public static bool ContainsAny(this string value, params string[] params) 
{ 
    return params.Any(p => value.Compare(p) > 0); 
    // or 
    return params.Any(p => value.Contains(p)); 
} 

Any任何，All为每

Answer 8

如果你正在寻找对于任意字符串，而不仅仅是字符，您可以使用IndexOfAny的重载，它从新项目中获取字符串参数NLib：

if (s.IndexOfAny("aaa", "bbb", "ccc", StringComparison.Ordinal) >= 0) 

Answer 9

var values = new [] {"abc", "def", "ghj"}; 
var str = "abcedasdkljre"; 
values.Any(str.Contains); 

Answer 10

这是一个“更好的解决方案”，并很简单

if(new string[] { "A", "B", ... }.Any(s=>myString.Contains(s))) 

Answer 11

如果您需要ContainsAny与特定StringComparison（例如忽略大小写），那么你可以使用这个字符串的一些推广方法。

public static class StringExtensions 
{ 
    public static bool ContainsAny(this string input, IEnumerable<string> containsKeywords, StringComparison comparisonType) 
    { 
     return containsKeywords.Any(keyword => input.IndexOf(keyword, comparisonType) >= 0); 
    } 
} 

用法与StringComparison.CurrentCultureIgnoreCase：

var input = "My STRING contains Many Substrings"; 
var substrings = new[] {"string", "many substrings", "not containing this string though" }; 
input.ContainsAny(substrings, StringComparison.CurrentCultureIgnoreCase); 
// The statement above returns true. 

”xyz”.ContainsAny(substrings, StringComparison.CurrentCultureIgnoreCase); 
// This statement returns false. 

Answer 12

public static bool ContainsAny(this string haystack, IEnumerable<string> needles) 
{ 
    return needles.Any(haystack.Contains); 
} 

Answer 13

List<string> includedWords = new List<string>() { "a", "b", "c" }; 
bool string_contains_words = includedWords.Exists(o => s.Contains(o)); 

Answer 14

static void Main(string[] args) 
    { 
     string illegalCharacters = "[email protected]#$%^&*()\\/{}|<>,.~`?"; //We'll call these the bad guys 
     string goodUserName = "John Wesson";     //This is a good guy. We know it. We can see it! 
                   //But what if we want the program to make sure? 
     string badUserName = "*_Wesson*_John!?";    //We can see this has one of the bad guys. Underscores not restricted. 

     Console.WriteLine("goodUserName " + goodUserName + 
      (!HasWantedCharacters(goodUserName, illegalCharacters) ? 
      " contains no illegal characters and is valid" :  //This line is the expected result 
      " contains one or more illegal characters and is invalid")); 
     string captured = ""; 
     Console.WriteLine("badUserName " + badUserName + 
      (!HasWantedCharacters(badUserName, illegalCharacters, out captured) ? 
      " contains no illegal characters and is valid" : 
      //We can expect this line to print and show us the bad ones 
      " is invalid and contains the following illegal characters: " + captured)); 

    } 

    //Takes a string to check for the presence of one or more of the wanted characters within a string 
    //As soon as one of the wanted characters is encountered, return true 
    //This is useful if a character is required, but NOT if a specific frequency is needed 
    //ie. you wouldn't use this to validate an email address 
    //but could use it to make sure a username is only alphanumeric 
    static bool HasWantedCharacters(string source, string wantedCharacters) 
    { 
     foreach(char s in source) //One by one, loop through the characters in source 
     { 
      foreach(char c in wantedCharacters) //One by one, loop through the wanted characters 
      { 
       if (c == s) //Is the current illegalChar here in the string? 
        return true; 
      } 
     } 
     return false; 
    } 

    //Overloaded version of HasWantedCharacters 
    //Checks to see if any one of the wantedCharacters is contained within the source string 
    //string source ~ String to test 
    //string wantedCharacters ~ string of characters to check for 
    static bool HasWantedCharacters(string source, string wantedCharacters, out string capturedCharacters) 
    { 
     capturedCharacters = ""; //Haven't found any wanted characters yet 

     foreach(char s in source) 
     { 
      foreach(char c in wantedCharacters) //Is the current illegalChar here in the string? 
      { 
       if(c == s) 
       { 
        if(!capturedCharacters.Contains(c.ToString())) 
         capturedCharacters += c.ToString(); //Send these characters to whoever's asking 
       } 
      } 
     } 

     if (capturedCharacters.Length > 0) 
      return true; 
     else 
      return false; 
    }