Utilisation de C # pour vérifier si la chaîne contient une chaîne dans un tableau de chaînes
Je veux utiliser C # pour vérifier si une valeur de chaîne contient un mot dans un tableau de chaînes. Par exemple,
string stringToCheck = "text1text2text3";
string[] stringArray = { "text1", "someothertext", etc... };
if(stringToCheck.contains stringArray) //one of the items?
{
}
Comment puis-je vérifier si la valeur de chaîne pour 'stringToCheck' contient un mot dans le tableau?
voici comment vous pouvez le faire:
string stringToCheck = "text1";
string[] stringArray = { "text1", "testtest", "test1test2", "test2text1" };
foreach (string x in stringArray)
{
if (stringToCheck.Contains(x))
{
// Process...
}
}
MISE À JOUR: Peut-être cherchez-vous une meilleure solution .. reportez-vous à la réponse de @Anton Gogolev ci-dessous, qui utilise LINQ.
Voici comment:
if(stringArray.Any(stringToCheck.Contains))
/* or a bit longer: (stringArray.Any(s => stringToCheck.Contains(s))) */
Ceci vérifie si stringToCheck contient l’une des sous-chaînes de stringArray. Si vous voulez vous assurer qu'il contient toutes les sous-chaînes, remplacez Any par All:
if(stringArray.All(stringToCheck.Contains))
Essaye ça:
Pas besoin d'utiliser LINQ
if (Array.IndexOf(array, Value) >= 0)
{
//Your stuff goes here
}
Il suffit d'utiliser la méthode linq:
stringArray.Contains(stringToCheck)
(Désolé, impossible d'ajouter un commentaire sur les réponses existantes car ma réputation est <50)
Manière la plus facile et exemple.
bool bol=Array.Exists(stringarray,E => E == stringtocheck);
Quelque chose comme ça peut-être:
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!");
}
Utiliser Linq et un groupe de méthodes serait le moyen le plus rapide et le plus compact.
var arrayA = new[] {"element1", "element2"};
var arrayB = new[] {"element2", "element3"};
if (arrayB.Any(arrayA.Contains)) return true;
string strName = "vernie";
string[] strNamesArray = { "roger", "vernie", "joel" };
if (strNamesArray.Any(x => x == strName))
{
// do some action here if true...
}
Essayer:
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));
Vous pouvez également faire la même chose que Anton Gogolev suggère de vérifier si un élément dans stringArray1 correspond à un élément dans stringArray2:
if(stringArray1.Any(stringArray2.Contains))
De même, tous les éléments dans stringArray1 correspondent tous les éléments dans stringArray2:
if(stringArray1.All(stringArray2.Contains))
Vous pouvez définir vos propres méthodes string.ContainsAny() et string.ContainsAll(). En prime, j'ai même ajouté une méthode string.Contains() qui permet une comparaison insensible à la casse, etc.
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));
}
}
Vous pouvez les tester avec le code suivant:
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();
}
}
Je voudrais utiliser Linq mais cela peut toujours être fait à travers:
new[] {"text1", "text2", "etc"}.Contains(ItemToFind);
J'utilise ce qui suit dans une application console pour vérifier les arguments
var sendmail = args.Any( o => o.ToLower() == "/sendmail=true");
Pour compléter les réponses ci-dessus, pour IgnoreCase check use:
stringArray.Any(s => stringToCheck.IndexOf(s, StringComparison.CurrentCultureIgnoreCase) > -1)
public bool ContainAnyOf(string Word, string[] array)
{
for (int i = 0; i < array.Length; i++)
{
if (Word.Contains(array[i]))
{
return true;
}
}
return false;
}
J'ai utilisé une méthode similaire à IndexOf de Maitrey684 et à la boucle foreach de Theomax pour le créer. (Remarque: les 3 premières lignes "chaîne" ne sont qu'un exemple de la manière dont vous pourriez créer un tableau et le placer dans le format approprié).
Si vous souhaitez comparer 2 tableaux, ils seront délimités par des points-virgules, mais la dernière valeur n'en suivra pas. Si vous ajoutez un point-virgule à la forme de chaîne du tableau (c.-à-d. A; b; c devient a; b; c;), vous pouvez faire correspondre à l'aide de "x;" peu importe dans quelle position il se trouve:
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) {
// ....
}
Pour mon cas, les réponses ci-dessus n'ont pas fonctionné. Je cherchais une chaîne dans un tableau et l'assignais à une valeur booléenne. J'ai modifié la réponse de @Anton Gogolev, supprimé la méthode Any() et placé stringToCheck dans la méthode Contains().
bool = stringArray.Contains(stringToCheck);
essayez ceci, voici l'exemple: Pour vérifier si le champ contient l'un des mots du tableau. Pour vérifier si le champ (someField) contient l'un des mots du tableau.
String[] val = { "helloword1", "orange", "grape", "pear" };
Expression<Func<Item, bool>> someFieldFilter = i => true;
someFieldFilter = i => val.Any(s => i.someField.Contains(s));
Essaye ça
string stringToCheck = "text1text2text3";
string[] stringArray = new string[] { "text1" };
var t = lines.ToList().Find(c => c.Contains(stringToCheck));
Il vous renverra la ligne avec la première incidence du texte que vous recherchez.
string [] lines = {"text1", "text2", "etc"};
bool bFound = lines.Any(x => x == "Your string to be searched");
bFound a la valeur true si la chaîne recherchée correspond à un élément du tableau "lignes".
Si stringArray contient un grand nombre de chaînes de longueurs variées, utilisez un Trie pour stocker et rechercher le tableau de chaînes.
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;
}
}
Voici l'implémentation de la classe 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;
}
Si toutes les chaînes dans stringArray ont la même longueur, vous feriez mieux d'utiliser simplement une HashSet au lieu d'une 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;
}
Solution simple, pas nécessaire linq aucun
String.Join (",", array) .Contains (Value ",");
int result = Array.BinarySearch(list.ToArray(), typedString, StringComparer.OrdinalIgnoreCase);
Essayez ceci, pas besoin de boucle ..
string stringToCheck = "text1";
List<string> stringList = new List<string>() { "text1", "someothertext", "etc.." };
if (stringList.Exists(o => stringToCheck.Contains(o)))
{
}