Usando C # para verificar se a string contém uma string na matriz de strings

290

Eu quero usar c # para verificar se um valor de seqüência de caracteres contém uma palavra em uma matriz de seqüência de caracteres. Por exemplo,

string stringToCheck = "text1text2text3";

string[] stringArray = { "text1", "someothertext", etc... };

if(stringToCheck.contains stringArray) //one of the items?
{

}

Como posso verificar se o valor da string 'stringToCheck' contém uma palavra na matriz?

Theomax
fonte
1
Este blog benchmarks numerosas técnicas para testar se uma string contém uma string: blogs.davelozinski.com/curiousconsultant/...
Robert Harvey

Respostas:

145

Aqui está como você pode fazer isso:

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

ATUALIZAÇÃO: Talvez você esteja procurando uma solução melhor. Consulte a resposta de @Anton Gogolev abaixo, que utiliza o LINQ.

Abdel Raoof
fonte
3
Obrigado, modifiquei seu código para: if (stringToCheck.Contains (s)) e funcionou.
Theomax 26/05
5
Eu fiz if (stringArray.Contains (stringToCheck)) e funciona muito bem, obrigado.
precisa
68
Não use este uso resposta LINQ vez
AlexC
11
Pequena observação para as pessoas que não vêem o método Contém na matriz de cadeias: Verifique se você tem um "using System.Linq;" namespace no seu CodeFile :)
Sudhanshu Mishra
5
O Linq nem sempre está disponível no software legado.
21813 William Morrison
842

Aqui está como:

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

Isso verifica se stringToCheckcontém alguma das substrings de stringArray. Se você deseja garantir que ele contenha todas as substrings, altere Anypara All:

if(stringArray.All(stringToCheck.Contains))
Anton Gogolev
fonte
115
Nota para si mesmo: linq é incrível, linq é incrível, linq é incrível! Tenho que começar a usar linq.
Fredrik Johansson
2
@Spooks LINQ to Objects (que é usado na cadeia de verificação da resposta) pode ser utilizada através LINQBridge em .NET 2.0 albahari.com/nutshell/linqbridge.aspx
David Rettenbacher
1
como você faria isso com invariância de caso?
Offler
14
@Offler Isso seria #stringArray.Any(s => s.IndexOf(stringToCheck, StringComparison.CurrentCultureIgnoreCase) > -1)
Anton Gogolev 11/11
2
como obter o item correspondente na matriz?
Ibubi 25/10/19
44

Tente o seguinte:

Não há necessidade de usar o LINQ

if (Array.IndexOf(array, Value) >= 0)
{
    //Your stuff goes here
}
Maitrey684
fonte
Agradável! E que benefício Linq poderia ter sobre Array.IndexOf ??
Heckflosse_230
21
Isso não resolve a questão. IndexOf informa se uma matriz contém uma correspondência exata para uma string, a pergunta original é se uma string contém uma de uma matriz de strings, que o Linq manipula facilmente.
NetMage 19/06/2014
Sei que esse comentário está atrasado, mas apenas para quem não sabe, uma string é uma matriz de caracteres, para que os tipos de string contenham um método IndexOf ... então, @NetMage é uma solução possível.
precisa
3
@ Blacky Wolf, você leu a pergunta? Array.IndexOf informa se uma matriz contém um valor, o OP queria saber se um valor contém algum membro de uma matriz, exatamente o oposto desta resposta. Você pode usar String.IndexOf com o Linq: stringArray.Any(w => stringToCheck.IndexOf(w) >= 0)mas a resposta do Linq usando o String.Contains faz mais sentido, pois é exatamente isso que está sendo solicitado.
NetMage
40

Basta usar o método linq:

stringArray.Contains(stringToCheck)
Legolas21
fonte
4
Note, que contém um método de extensão e que você precisa fazerusing System.Linq;
isHuman
11
Esta resposta está ao contrário da pergunta.
NetMage
1
Como essa resposta foi votada tantas vezes? 5 anos após a pergunta ser feita e a solução é basicamente revertida do que a pergunta está sendo feita.
Fus Ro Dah
1
talvez apenas inverta os nomes das variáveis, tudo ficará bem?
Jean-François Fabre
8

Maneira mais fácil e amostra.

  bool bol=Array.Exists(stringarray,E => E == stringtocheck);
Jze
fonte
melhor é stringarray.Exists (entidade => entidade == stringtocheck)
Marcel gruger
Eu acho que você não pode chamar o método existe diretamente da matriz de strings. O método Exists pode ser usado diretamente para a lista <T>. Portanto, você deve usar o método estático array.exist <T> para a string array.check here => msdn.microsoft.com/en- us / library / yw84x8be (v = vs.110) .aspx
Jze
6
string strName = "vernie";
string[] strNamesArray = { "roger", "vernie", "joel" };

if (strNamesArray.Any(x => x == strName))
{
   // do some action here if true...
}
Vernie Namca
fonte
2
Eu não acho que isso é o que a pergunta está pedindo.
dez /
5

Algo assim talvez:

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!");
}
Fredrik Johansson
fonte
Essa é uma solução melhor, pois é uma verificação de substring contra palavras em uma lista, em vez de uma verificação de correspondência exata.
Roy B
Boa resposta, mas uau, que é difícil de ler em comparação com o C # moderno, mesmo sem o Linq; Além disso, String.Containspode ser melhor do que, a String.IndexOfmenos que você queira ignorar o caso, uma vez que a Microsoft esqueceu um argumento de dois, String.Containsvocê deve escrever o seu próprio. Considere:Array.Exists(stringArray, s => stringToCheck.IndexOf(s, StringComparison.OrdinalIgnoreCase) > -1)
NetMage
3

Usar o Linq e o grupo de métodos seria a maneira mais rápida e compacta de fazer isso.

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

Você pode definir o seu próprio string.ContainsAny()e string.ContainsAll()métodos. Como bônus, eu até joguei um string.Contains()método que permite uma comparação sem distinção entre maiúsculas e minúsculas, 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));
    }
}

Você pode testá-los com o seguinte código:

    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();
        }
    }
Kyle Delaney
fonte
2

Eu uso o seguinte em um aplicativo de console para verificar argumentos

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

Eu usaria o Linq, mas ainda pode ser feito através de:

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

Experimentar:

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));
Valko
fonte
1

Você também pode fazer a mesma coisa que Anton Gogolev sugere para verificar se qualquer item em stringArray1corresponda qualquer item em stringArray2:

if(stringArray1.Any(stringArray2.Contains))

E da mesma forma todos os itens em stringArray1 correspondem a todos os itens em stringArray2:

if(stringArray1.All(stringArray2.Contains))
Scotty.NET
fonte
1
stringArray.ToList().Contains(stringToCheck)
Christer Carlsson
fonte
0

tente isto, aqui o exemplo: Para verificar se o campo contém alguma das palavras na matriz. Para verificar se o campo (someField) contém alguma das palavras na matriz.

String[] val = { "helloword1", "orange", "grape", "pear" };   

Expression<Func<Item, bool>> someFieldFilter = i => true;

someFieldFilter = i => val.Any(s => i.someField.Contains(s));
Vijay
fonte
0
public bool ContainAnyOf(string word, string[] array) 
    {
        for (int i = 0; i < array.Length; i++)
        {
            if (word.Contains(array[i]))
            {
                return true;
            }
        }
        return false;
    }
nakisa
fonte
0

Usei um método semelhante ao IndexOf de Maitrey684 e ao loop foreach de Theomax para criar isso. (Nota: as 3 primeiras linhas de "sequência" são apenas um exemplo de como você pode criar uma matriz e colocá-la no formato correto).

Se você quiser comparar duas matrizes, elas serão delimitadas por ponto e vírgula, mas o último valor não terá um depois. Se você anexar um ponto-e-vírgula à forma de seqüência de caracteres da matriz (ou seja, a; b; c se torna a; b; c;), poderá fazer a correspondência usando "x;" não importa em que posição esteja:

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) { 
    // ....
}
vapcguy
fonte
0
string [] lines = {"text1", "text2", "etc"};

bool bFound = lines.Any(x => x == "Your string to be searched");

bFound será true se a string pesquisada corresponder a qualquer elemento das 'linhas' da matriz.

Pabitra Dash
fonte
0

Tente isto

string stringToCheck = "text1text2text3";
string[] stringArray = new string[] { "text1" };

var t = lines.ToList().Find(c => c.Contains(stringToCheck));

Ele retornará a linha com a primeira incidência do texto que você está procurando.

Fernando Chávez
fonte
0

Se stringArraycontiver um grande número de cadeias de comprimento variadas, considere usar uma Trie para armazenar e pesquisar na matriz de cadeias.

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

Aqui está a implementação da Trieclasse

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

Se todas as seqüências de caracteres stringArraytiverem o mesmo comprimento, será melhor usar apenas um ao HashSetinvés de umTrie

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;
}
tcb
fonte
0

Solução simples, não é necessário linq qualquer

String.Join (",", array) .Contains (Value + ",");

user5789849
fonte
2
E se um dos valores na matriz contiver seu delimitador?
Tyler Benzing
0
int result = Array.BinarySearch(list.ToArray(), typedString, StringComparer.OrdinalIgnoreCase);
amit jha
fonte
0

Tente isso, não há necessidade de um loop ..

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

}
Amjad Abu Saa
fonte
0

Para concluir as respostas acima, para a verificação do IgnoreCase, use:

stringArray.Any(s => stringToCheck.IndexOf(s, StringComparison.CurrentCultureIgnoreCase) > -1)
Shady Sirhan
fonte
Existe alguma maneira de obter o índice da partida com isso também? Obrigado.
Si8
0

Para o meu caso, as respostas acima não funcionaram. Eu estava verificando uma string em uma matriz e atribuindo-a a um valor booleano. Modifiquei a resposta de @Anton Gogolev e removi o Any()método e coloquei o stringToCheckinterior do Contains()método.

bool = stringArray.Contains(stringToCheck);
Matthew Miranda
fonte
0

Usando os métodos Find ou FindIndex da classe Array :

if(Array.Find(stringArray, stringToCheck.Contains) != null) 
{ 
}
if(Array.FindIndex(stringArray, stringToCheck.Contains) != -1) 
{ 
}
Andriy Tolstoy
fonte
-1

Usei o seguinte código para verificar se a string continha algum dos itens na matriz de string:

foreach (string s in stringArray)
{
    if (s != "")
    {
        if (stringToCheck.Contains(s))
        {
            Text = "matched";
        }
    }
}
Theomax
fonte
3
Isso define Text = "matched"quantas vezes stringToCheckcontém substrings de stringArray. Você pode colocar uma breakou returndepois da tarefa.
Dour High Arch
-1

Três opções demonstradas. Prefiro encontrar o terceiro como o mais 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();
    }
}
Steve
fonte
Suas duas segundas opções nem fazem a mesma coisa na primeira.
Kyle Delaney