Использование C# для проверки, содержит ли строка строку в массиве строк
Я хочу использовать C#, чтобы проверить, содержит ли строковое значение слово в строковом массиве. Например,
string stringToCheck = "text1text2text3";
string[] stringArray = { "text1", "someothertext", etc... };
if(stringToCheck.contains stringArray) //one of the items?
{
}
Как я могу проверить, содержит ли строковое значение для 'stringToCheck' слово в массиве?
25 ответов
вот как вы можете сделать это:
string stringToCheck = "text1";
string[] stringArray = { "text1", "testtest", "test1test2", "test2text1" };
foreach (string x in stringArray)
{
if (stringToCheck.Contains(x))
{
// Process...
}
}
обновление: может быть вы ищете лучшее решение.. см. ответ @Anton Gogolev ниже, в котором используется LINQ.
вот так:
if(stringArray.Any(stringToCheck.Contains))
/* or a bit longer: (stringArray.Any(s => stringToCheck.Contains(s))) */
это проверяет, является ли stringToCheck
содержит любую из последовательностей от stringArray
. Если вы хотите убедиться, что он содержит все подстроки, измените Any
до All
:
if(stringArray.All(stringToCheck.Contains))
попробуйте это:
нет необходимости использовать LINQ
if (Array.IndexOf(array, Value) >= 0)
{
//Your stuff goes here
}
просто используйте метод linq:
stringArray.Contains(stringToCheck)
(извините, не могу добавить комментарий к существующим ответам, так как моя репутация
что-то вроде этого может быть:
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!");
}
string strName = "vernie";
string[] strNamesArray = { "roger", "vernie", "joel" };
if (strNamesArray.Any(x => x == strName))
{
// do some action here if true...
}
использование Linq и группы методов было бы самым быстрым и более компактным способом сделать это.
var arrayA = new[] {"element1", "element2"};
var arrayB = new[] {"element2", "element3"};
if (arrayB.Any(arrayA.Contains)) return true;
попробуй:
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));
вы также можете сделать то же самое, что Антон Гоголев предлагает проверить если любой пункт на stringArray1
игр любой пункт на stringArray2
:
if(stringArray1.Any(stringArray2.Contains))
, а также все товары в stringArray1 матч все товары в stringArray2:
if(stringArray1.All(stringArray2.Contains))
Я использую следующее в консольном приложении для проверки аргументов
var sendmail = args.Any( o => o.ToLower() == "/sendmail=true");
Я бы использовал Linq, но это все еще можно сделать через:
new[] {"text1", "text2", "etc"}.Contains(ItemToFind);
вы можете определить свой собственный 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));
}
}
вы можете проверить их со следующим кодом:
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();
}
}
попробуйте это, вот пример: чтобы проверить, содержит ли поле какое-либо из слов в массиве. Чтобы проверить, содержит ли поле (someField) какое-либо из слов в массиве.
String[] val = { "helloword1", "orange", "grape", "pear" };
Expression<Func<Item, bool>> 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;
}
я использовал аналогичный метод IndexOf by Maitrey684 и цикл foreach Theomax для создания этого. (Примечание: первые 3 строки "string" - это просто пример того, как вы можете создать массив и получить его в надлежащем формате).
Если вы хотите сравнить 2 массива, они будут точками с запятой, но последнее значение не будет после нее. Если вы добавляете двоеточие к Строковой форме массива (т. е. 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) {
// ....
}
string [] lines = {"text1", "text2", "etc"};
bool bFound = lines.Any(x => x == "Your string to be searched");
bfound устанавливает значение true, если искомая строка соответствует любому элементу массива "lines".
попробуй такое
string stringToCheck = "text1text2text3";
string[] stringArray = new string[] { "text1" };
var t = lines.ToList().Find(c => c.Contains(stringToCheck));
он вернет вам строку с первым случаем текста, который вы ищете.
если stringArray
содержит большое количество строк различной длины, рассмотрите возможность использования Trie для хранения и поиска в массиве строк.
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;
}
}
вот реализация Trie
класс
public class Trie
{
public Trie(IEnumerable<string> words)
{
Root = new Node { Letter = '' };
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;
}
если все строки в 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;
}
попробуйте это, нет необходимости в цикле..
string stringToCheck = "text1";
List<string> stringList = new List<string>() { "text1", "someothertext", "etc.." };
if (stringList.Exists(o => stringToCheck.Contains(o)))
{
}
чтобы завершить приведенные выше ответы, для параметром ignorecase проверить использовать:
stringArray.Any(s => stringToCheck.IndexOf(s, StringComparison.CurrentCultureIgnoreCase) > -1)
я использовал следующий код, чтобы проверить, если строка содержит какие-либо элементы в массив строк:
foreach (string s in stringArray)
{
if (s != "")
{
if (stringToCheck.Contains(s))
{
Text = "matched";
}
}
}
три варианта показал. Я предпочитаю считать третье наиболее кратким.
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();
}
}