Wie überprüft man, ob eine Zeichenfolge einige Zeichenfolgen enthält

Question

Ich möchte prüfen, ob ein String s, enthält "a" oder "b" oder "c", in C#. Ich suche eine schönere Lösung als die Verwendung von

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

Answer 1

Wenn Sie für einzelne Zeichen suchen können, können Sie String.IndexOfAny() verwenden.

Wenn Sie beliebige Strings wollen, dann ist mir keine .NET-Methode bekannt, um das "direkt" zu erreichen, obwohl ein regulärer Ausdruck funktionieren würde.

Answer 2

Nun, es gibt immer:

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

    return false; 
} 

Verbrauch:

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

Nichts wird die Leistung Ihrer Kette von || anzupassen Vergleiche jedoch.

Answer 3

Sie können mit regulären Ausdrücken versuchen

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

Answer 4

Sie Regular Expressions

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

Answer 5

Hier ist eine LINQ-Lösung, die praktisch die gleiche ist, aber besser skalierbar:

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

Answer 6

Als Zeichenfolge ist eine Sammlung von Zeichen, können Sie LINQ-Erweiterungsmethoden auf sie verwenden:

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

Diese scannt die Zeichenfolge einmal und stoppt beim ersten Auftreten, anstatt die Zeichenfolge für jedes Zeichen einmal zu scannen, bis eine Übereinstimmung gefunden wird.

Dies kann auch für jeden Ausdruck verwendet werden, die Sie mögen, zum Beispiel für eine Reihe von Zeichen Überprüfung:

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 für alle, All für jeden

Answer 8

Wenn Sie schauen, Für beliebige Zeichenfolgen und nicht nur für Zeichen können Sie eine Überladung von IndexOfAny verwenden, die Zeichenfolgenargumente aus dem neuen Projekt NLib:

übernimmt

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

Dies ist eine „schönere Lösung“ und ganz einfach

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

Answer 11

Wenn Sie ContainsAny mit einem spezifischen StringComparison (zB Fall zu ignorieren) benötigen, dann können Sie diesen String Extentions Methode verwenden.

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

Verwendung mit 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 = "!@#$%^&*()\\/{}|<>,.~`?"; //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; 
    }