Usando C # per verificare se la stringa contiene una stringa nell’array di stringhe

Voglio usare C # per verificare se un valore stringa contiene una parola in un array di stringhe. Per esempio,

string stringToCheck = "text1text2text3"; string[] stringArray = { "text1", "someothertext", etc... }; if(stringToCheck.contains stringArray) //one of the items? { } 

Come posso verificare se il valore di stringa per ‘stringToCheck’ contiene una parola nell’array?

Ecco come puoi farlo:

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

AGGIORNAMENTO: Potrebbe essere che stai cercando una soluzione migliore .. fai riferimento alla risposta di @Anton Gogolev in basso che fa uso di LINQ.

Ecco come:

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

Questo controlla se stringToCheck contiene una qualsiasi delle sottostringhe da stringArray . Se vuoi assicurarti che contenga tutte le sottostringhe, modifica Any a All :

 if(stringArray.All(stringToCheck.Contains)) 

Prova questo:

Non c’è bisogno di usare LINQ

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

Basta usare il metodo linq:

 stringArray.Contains(stringToCheck) 

(Non è ansible aggiungere un commento alle risposte esistenti in quanto la mia reputazione è <50)

Modo più semplice e di prova.

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

Qualcosa di simile forse:

 string stringToCheck = "text1text2text3"; string[] stringArray = new string[] { "text1" }; if (Array.Exists(stringArray, (Predicate)delegate(string s) { return stringToCheck.IndexOf(s, StringComparison.OrdinalIgnoreCase) > -1; })) { Console.WriteLine("Found!"); } 
 string strName = "vernie"; string[] strNamesArray = { "roger", "vernie", "joel" }; if (strNamesArray.Any(x => x == strName)) { // do some action here if true... } 

L’uso di Linq e del gruppo di metodi sarebbe il modo più rapido e compatto di farlo.

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

Userò Linq ma può ancora essere fatto attraverso:

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

Provare:

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

Puoi anche fare la stessa cosa che Anton Gogolev suggerisce di verificare se qualsiasi elemento in stringArray1 corrisponde a qualsiasi elemento in stringArray2 :

 if(stringArray1.Any(stringArray2.Contains)) 

Allo stesso modo, tutti gli elementi in stringArray1 corrispondono a tutti gli elementi in stringArray2:

 if(stringArray1.All(stringArray2.Contains)) 

Io uso il seguente in un’applicazione console per verificare gli argomenti

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

È ansible definire i propri string.ContainsAny() e string.ContainsAll() . Come bonus, ho persino gettato un metodo string.Contains() che consente confronti tra maiuscole e minuscole, ecc.

 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 values, StringComparison comp = StringComparison.CurrentCulture) { return values.Any(value => source.Contains(value, comp)); } public static bool ContainsAll(this string source, IEnumerable values, StringComparison comp = StringComparison.CurrentCulture) { return values.All(value => source.Contains(value, comp)); } } 

Puoi testarli con il seguente codice:

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

prova questo, ecco l’esempio: per verificare se il campo contiene una delle parole nella matrice. Per verificare se il campo (someField) contiene una delle parole nella matrice.

 String[] val = { "helloword1", "orange", "grape", "pear" }; Expression> 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; } 

Ho usato un metodo simile a IndexOf di Maitrey684 e al ciclo foreach di Theomax per creare questo. (Nota: le prime 3 righe “stringa” sono solo un esempio di come è ansible creare un array e inserirlo nel formato corretto).

Se vuoi confrontare 2 array, saranno delimitati da punto e virgola, ma l’ultimo valore non ne avrà uno dopo. Se si aggiunge un punto e virgola alla forma di stringa dell’array (ad esempio a; b; c diventa a; b; c;), è ansible eseguire l’abbinamento utilizzando “x;” indipendentemente dalla posizione in cui si trova:

 bool found = false; string someString = "abc"; 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 si imposta su true se la stringa cercata corrisponde a qualsiasi elemento delle ‘linee’ dell’array.

Prova questo

 string stringToCheck = "text1text2text3"; string[] stringArray = new string[] { "text1" }; var t = lines.ToList().Find(c => c.Contains(stringToCheck)); 

Ti restituirà la linea con la prima incidenza del testo che stai cercando.

Se stringArray contiene un numero elevato di stringhe di lunghezze diverse, prendere in considerazione l’utilizzo di un Trie per archiviare e cercare l’array di stringhe.

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

Ecco l'implementazione della class Trie

 public class Trie { public Trie(IEnumerable 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 Links = new SortedList(); public bool IsWord; } private Node Root; } 

Se tutte le stringhe in stringArray hanno la stessa lunghezza, stringArray meglio usando un HashSet invece di un Trie

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

Soluzione semplice, non richiesta linq any

String.Join (“,”, array) .Contains (Value + “,”);

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

Prova questo, non c’è bisogno di un loop ..

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

Ho usato il seguente codice per verificare se la stringa conteneva uno degli elementi nell’array di stringhe:

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

Tre opzioni dimostrate. Preferisco trovare il terzo come il più conciso.

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