Usando C # para verificar si la cadena contiene una cadena en la matriz

290

Quiero usar C # para verificar si un valor de cadena contiene una palabra en una matriz de cadenas. Por ejemplo,

string stringToCheck = "text1text2text3";

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

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

}

¿Cómo puedo verificar si el valor de cadena para 'stringToCheck' contiene una palabra en la matriz?

Theomax
fuente
1
Este blog compara numerosas técnicas para probar si una cadena contiene una cadena: blogs.davelozinski.com/curiousconsultant/…
Robert Harvey

Respuestas:

145

Aquí sabrás como podrás hacerlo:

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

ACTUALIZACIÓN: Puede que esté buscando una solución mejor ... consulte la respuesta de @Anton Gogolev a continuación que hace uso de LINQ.

Abdel Raoof
fuente
3
Gracias, modifiqué su código a: if (stringToCheck.Contains (s)) y funcionó.
Theomax
55
Lo hice if (stringArray.Contains (stringToCheck)) y funciona muy bien, gracias.
Tamara JQ
68
No use esta respuesta use LINQ en su lugar
AlexC
11
Pequeña nota para las personas que no ven el método Contiene en la matriz de cadenas: Compruebe si tiene un "uso de System.Linq;" espacio de nombres en su archivo de código :)
Sudhanshu Mishra
55
Linq no siempre está disponible en software heredado.
William Morrison
842

Así es cómo:

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

Esto comprueba si stringToCheckcontiene cualquiera de las subcadenas de stringArray. Si desea asegurarse de que contiene todas las subcadenas, cambie Anya All:

if(stringArray.All(stringToCheck.Contains))
Anton Gogolev
fuente
115
Nota personal: ¡linq es increíble, linq es increíble, linq es increíble! Tengo que empezar a usar linq.
Fredrik Johansson
2
@Spooks Linq To Objects (que se usa en la verificación de la cadena de respuesta) se puede usar a través de LinqBridge en .NET 2.0 albahari.com/nutshell/linqbridge.aspx
David Rettenbacher
1
¿Cómo harías esto con la invariancia de casos?
Offler
14
@Offler Eso seríastringArray.Any(s => s.IndexOf(stringToCheck, StringComparison.CurrentCultureIgnoreCase) > -1)
Anton Gogolev
2
¿Cómo hacer coincidir qué elemento de la matriz?
ibubi
44

Prueba esto:

No es necesario usar LINQ

if (Array.IndexOf(array, Value) >= 0)
{
    //Your stuff goes here
}
Maitrey684
fuente
¡Agradable! ¿Y qué beneficio podría tener Linq sobre Array.IndexOf ??
Heckflosse_230
21
Esto no resuelve la pregunta en absoluto. IndexOf le dice si una matriz contiene una coincidencia exacta para una cadena, la pregunta original es si una cadena contiene una de una serie de cadenas, que Linq maneja fácilmente.
NetMage
Sé que este comentario llega tarde, pero solo para aquellos que no lo saben, una cadena es una matriz de caracteres, por lo que los tipos de cadena contienen un método IndexOf ... entonces @NetMage es una posible solución.
Blacky Wolf
3
@Blacky Wolf, ¿leíste la pregunta? Array.IndexOf le dice si una matriz contiene un valor, el OP quería saber si un valor contiene algún miembro de una matriz, exactamente lo contrario de esta respuesta. Podría usar String.IndexOf con Linq: stringArray.Any(w => stringToCheck.IndexOf(w) >= 0)pero la respuesta de Linq usando String.Contains tiene más sentido, ya que eso es exactamente lo que se solicita.
NetMage
40

Solo usa el método linq:

stringArray.Contains(stringToCheck)
Legolas21
fuente
44
Tenga en cuenta que Contains es un método de extensión y debe hacerlousing System.Linq;
isHuman
11
Esta respuesta es al revés de la pregunta.
NetMage
1
¿Cómo se ha votado esta respuesta tantas veces? 5 años después de que se hace la pregunta y la solución se invierte básicamente de lo que está haciendo la pregunta.
Fus Ro Dah
1
tal vez solo invierta los nombres de las variables, ¿estará bien?
Jean-François Fabre
8

La forma más fácil y de muestra.

  bool bol=Array.Exists(stringarray,E => E == stringtocheck);
Jze
fuente
mejor es stringarray.Exists (entity => entity == stringtocheck)
Marcel Grüger
Creo que no puede llamar al método existente directamente desde la matriz de cadenas. El método existente puede usarse directamente para la lista <T>. Por lo tanto, debe usar el método estático array.exist <T> para la cadena 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
fuente
2
No creo que esto sea lo que pregunta.
Pang
5

Algo como esto quizás:

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
fuente
Esta es una mejor solución, ya que es una verificación de subcadena contra palabras en una lista en lugar de una verificación de coincidencia exacta.
Roy B
Buena respuesta, pero wow, eso es difícil de leer en comparación con C # moderno incluso sin Linq; Además, String.Containspodría ser mejor que a String.IndexOfmenos que desee ignorar el caso, ya que Microsoft olvidó un argumento doble String.Containsque tiene que escribir el suyo. Considere:Array.Exists(stringArray, s => stringToCheck.IndexOf(s, StringComparison.OrdinalIgnoreCase) > -1)
NetMage
3

Usar Linq y el grupo de métodos sería la forma más rápida y compacta de hacerlo.

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

Puede definir sus propios string.ContainsAny()y string.ContainsAll()métodos. Como string.Contains()beneficio adicional, incluso he incluido un método que permite la comparación entre mayúsculas y 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));
    }
}

Puede probarlos con el siguiente 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
fuente
2

Uso lo siguiente en una aplicación de consola para verificar argumentos

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

Usaría Linq pero aún se puede hacer a través de:

new[] {"text1", "text2", "etc"}.Contains(ItemToFind);
Mármol Nublado
fuente
1

Tratar:

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
fuente
1

También se puede hacer la misma cosa que Anton Gogolev sugiere para comprobar si cualquier artículo en stringArray1coincide con cualquier artículo en stringArray2:

if(stringArray1.Any(stringArray2.Contains))

Y del mismo modo, todos los elementos en stringArray1 coinciden con todos los elementos en stringArray2:

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

intente esto, aquí el ejemplo: Para verificar si el campo contiene alguna de las palabras en la matriz. Para verificar si el campo (someField) contiene alguna de las palabras en la matriz.

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

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

someFieldFilter = i => val.Any(s => i.someField.Contains(s));
Vijay
fuente
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
fuente
0

Utilicé un método similar al IndexOf de Maitrey684 y el bucle foreach de Theomax para crear esto. (Nota: las primeras 3 líneas de "cadenas" son solo un ejemplo de cómo podría crear una matriz y ponerla en el formato adecuado).

Si desea comparar 2 matrices, estarán delimitadas por punto y coma, pero el último valor no tendrá una después. Si agrega un punto y coma a la forma de cadena de la matriz (es decir, a; b; c se convierte en a; b; c;), puede hacer coincidir usando "x;" no importa en qué posición se encuentre:

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
fuente
0
string [] lines = {"text1", "text2", "etc"};

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

bFound se establece en true si la cadena buscada coincide con cualquier elemento de la matriz 'líneas'.

Pabitra Dash
fuente
0

Prueba esto

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

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

Le devolverá la línea con la primera incidencia del texto que está buscando.

Fernando Chávez
fuente
0

Si stringArraycontiene una gran cantidad de cadenas de longitud variada, considere usar un Trie para almacenar y buscar la matriz de cadenas.

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

Aquí está la implementación de la Trieclase.

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 todas las cadenas stringArraytienen la misma longitud, será mejor usar solo una en HashSetlugar de unaTrie

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
fuente
0

Solución simple, no se requiere linq ninguna

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

usuario5789849
fuente
2
¿Qué sucede si uno de los valores en la matriz contiene su delimitador?
Tyler Benzing
0
int result = Array.BinarySearch(list.ToArray(), typedString, StringComparer.OrdinalIgnoreCase);
amit jha
fuente
0

Prueba esto, no necesitas un bucle.

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

}
Amjad Abu Saa
fuente
0

Para completar las respuestas anteriores, para la verificación IgnoreCase use:

stringArray.Any(s => stringToCheck.IndexOf(s, StringComparison.CurrentCultureIgnoreCase) > -1)
Shady Sirhan
fuente
¿Hay alguna forma de obtener el índice del partido con eso también? Gracias.
Si8
0

Para mi caso, las respuestas anteriores no funcionaron. Estaba buscando una cadena en una matriz y asignándola a un valor booleano. Modifiqué la respuesta de @Anton Gogolev y eliminé el Any()método y lo puse stringToCheckdentro del Contains()método.

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

Usando los métodos Find o FindIndex de la clase Array :

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

Usé el siguiente código para verificar si la cadena contenía alguno de los elementos de la matriz de cadenas:

foreach (string s in stringArray)
{
    if (s != "")
    {
        if (stringToCheck.Contains(s))
        {
            Text = "matched";
        }
    }
}
Theomax
fuente
3
Esto establece Text = "matched"tantas veces como stringToCheckcontiene subcadenas de stringArray. Es posible que desee poner un breako returndespués de la tarea.
Dour High Arch
-1

Tres opciones demostradas. Prefiero encontrar el tercero como el más 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
fuente
Las segundas dos opciones ni siquiera hacen lo mismo en la primera.
Kyle Delaney el