Verwenden Sie C #, um zu überprüfen, ob der String einen String im String-Array enthält

290

Ich möchte C # verwenden, um zu überprüfen, ob ein Zeichenfolgenwert ein Wort in einem Zeichenfolgenarray enthält. Zum Beispiel,

string stringToCheck = "text1text2text3";

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

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

}

Wie kann ich überprüfen, ob der Zeichenfolgenwert für 'stringToCheck' ein Wort im Array enthält?

Theomax
quelle
1
Dieser Blog vergleicht zahlreiche Techniken zum Testen, ob eine Zeichenfolge eine Zeichenfolge enthält: blogs.davelozinski.com/curiousconsultant/…
Robert Harvey

Antworten:

145

Hier ist, wie Sie es tun können:

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

UPDATE: Vielleicht suchen Sie nach einer besseren Lösung. Lesen Sie die Antwort von @Anton Gogolev, in der LINQ verwendet wird.

Abdel Raoof
quelle
3
Vielen Dank, ich habe Ihren Code geändert in: if (stringToCheck.Contains (s)) und es hat funktioniert.
Theomax
5
Ich habe if (stringArray.Contains (stringToCheck)) gemacht und es funktioniert großartig, danke.
Tamara JQ
68
Verwenden Sie diese Antwort nicht, sondern verwenden Sie stattdessen LINQ
AlexC
11
Kleiner Hinweis für Personen, die die Contains- Methode im String-Array nicht sehen : Überprüfen Sie, ob Sie ein "using System.Linq;" Namespace in Ihrem Codefile :)
Sudhanshu Mishra
5
Linq ist in Legacy-Software nicht immer verfügbar.
William Morrison
842

Hier ist wie:

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

Dies prüft, ob stringToCheckeine der Teilzeichenfolgen von enthalten ist stringArray. Wenn Sie sicherstellen möchten, dass alle Teilzeichenfolgen enthalten sind, wechseln Sie Anyzu All:

if(stringArray.All(stringToCheck.Contains))
Anton Gogolev
quelle
115
Hinweis für sich selbst: Linq ist erstaunlich, Linq ist erstaunlich, Linq ist erstaunlich! Ich muss anfangen, linq zu verwenden.
Fredrik Johansson
2
@Spooks Linq To Objects (das in der Zeichenfolgenprüfung der Antwort verwendet wird) kann über LinqBridge auf .NET 2.0 verwendet werden. Albahari.com/nutshell/linqbridge.aspx
David Rettenbacher
1
Wie würden Sie dies mit Fallinvarianz tun?
Offler
14
@Offler Das wärestringArray.Any(s => s.IndexOf(stringToCheck, StringComparison.CurrentCultureIgnoreCase) > -1)
Anton Gogolev
2
Wie kann man feststellen, welches Element im Array übereinstimmt?
Ibubi
44

Versuche dies:

LINQ muss nicht verwendet werden

if (Array.IndexOf(array, Value) >= 0)
{
    //Your stuff goes here
}
Maitrey684
quelle
Nett! Und welchen Nutzen könnte Linq möglicherweise gegenüber Array.IndexOf haben?
Heckflosse_230
21
Dies löst die Frage überhaupt nicht. IndexOf gibt an, ob ein Array eine genaue Übereinstimmung für eine Zeichenfolge enthält. Die ursprüngliche Frage lautet, ob eine Zeichenfolge eine Zeichenfolge aus einem Array von Zeichenfolgen enthält, die von Linq problemlos verarbeitet werden kann.
NetMage
Ich weiß, dass dieser Kommentar zu spät ist, aber nur für diejenigen, die es nicht wissen, ist eine Zeichenfolge ein Array von Zeichen, sodass Zeichenfolgentypen eine IndexOf-Methode enthalten ... also @NetMage ist dies eine mögliche Lösung.
Blacky Wolf
3
@ Black Wolf, hast du die Frage gelesen? Array.IndexOf teilt Ihnen mit, ob ein Array einen Wert enthält. Das OP wollte wissen, ob ein Wert ein Mitglied eines Arrays enthält, genau das Gegenteil dieser Antwort. Sie könnten String.IndexOf mit Linq verwenden: stringArray.Any(w => stringToCheck.IndexOf(w) >= 0)Die Linq-Antwort mit String.Contains ist jedoch sinnvoller, da genau danach gefragt wird.
NetMage
40

Verwenden Sie einfach die linq-Methode:

stringArray.Contains(stringToCheck)
Legolas21
quelle
4
Beachten Sie, dass Contains eine Erweiterungsmethode ist und Sie dies tun müssenusing System.Linq;
isHuman
11
Diese Antwort ist rückwärts von der Frage.
NetMage
1
Wie wurde diese Antwort so oft positiv bewertet? 5 Jahre nachdem die Frage gestellt wurde und die Lösung im Grunde umgekehrt ist, was die Frage stellt.
Fus Ro Dah
1
Vielleicht einfach die Variablennamen umkehren, wird es in Ordnung sein?
Jean-François Fabre
8

Einfachste und einfachste Art und Weise.

  bool bol=Array.Exists(stringarray,E => E == stringtocheck);
Jze
quelle
besser ist stringarray.Exists (entity => entity == stringtocheck)
Marcel Grüger
Ich denke, Sie können keine existierende Methode direkt aus dem String-Array aufrufen. Die Exists-Methode kann direkt für die Liste <T> verwendet werden. Daher sollte die statische Methode array.exist <T> für das String-Array verwendet werden. Überprüfen Sie hier => 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
quelle
2
Ich glaube nicht, dass dies die Frage ist.
Pang
5

So etwas vielleicht:

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
quelle
Dies ist eine bessere Lösung, da es sich um eine Teilzeichenfolgenprüfung anhand von Wörtern in einer Liste handelt, anstatt um eine genaue Übereinstimmungsprüfung.
Roy B
Schöne Antwort, aber wow, das ist im Vergleich zu modernem C # auch ohne Linq schwer zu lesen. Auch String.Containskönnte besser sein , als String.IndexOfwenn Sie Fall zu ignorieren, da Microsoft ein zwei Argument vergessen String.Containshaben Sie Ihre eigenen schreiben. Bedenken Sie:Array.Exists(stringArray, s => stringToCheck.IndexOf(s, StringComparison.OrdinalIgnoreCase) > -1)
NetMage
3

Die Verwendung von Linq und Methodengruppen wäre der schnellste und kompaktere Weg, dies zu tun.

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

Sie können Ihre eigenen string.ContainsAny()und string.ContainsAll()Methoden definieren. Als Bonus habe ich sogar eine string.Contains()Methode eingeführt, die einen Vergleich ohne Berücksichtigung der Groß- und Kleinschreibung usw. ermöglicht.

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

Sie können diese mit folgendem Code testen:

    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
quelle
2

Ich verwende Folgendes in einer Konsolenanwendung, um nach Argumenten zu suchen

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

Ich würde Linq verwenden, aber es kann immer noch getan werden durch:

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

Versuchen:

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

Sie können auch das Gleiche tun, wie Anton Gogolev vorschlägt, um zu überprüfen, ob ein Artikel in stringArray1mit einem Artikel in übereinstimmt stringArray2:

if(stringArray1.Any(stringArray2.Contains))

Ebenso stimmen alle Elemente in stringArray1 mit allen Elementen in stringArray2 überein:

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

Versuchen Sie dies, hier das Beispiel: Um zu überprüfen, ob das Feld eines der Wörter im Array enthält. Um zu überprüfen, ob das Feld (someField) eines der Wörter im Array enthält.

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

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

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

Ich habe eine ähnliche Methode wie IndexOf von Maitrey684 und die foreach-Schleife von Theomax verwendet, um dies zu erstellen. (Hinweis: Die ersten 3 "String" -Zeilen sind nur ein Beispiel dafür, wie Sie ein Array erstellen und in das richtige Format bringen können.)

Wenn Sie zwei Arrays vergleichen möchten, werden diese durch Semikolons getrennt, aber der letzte Wert hat keinen nach. Wenn Sie ein Semikolon an die Zeichenfolgenform des Arrays anhängen (dh a; b; c wird zu a; b; c;), können Sie mit "x;" egal in welcher Position es ist:

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

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

bFound wird auf true gesetzt, wenn die gesuchte Zeichenfolge mit einem Element des Arrays 'lines' übereinstimmt.

Pabitra Dash
quelle
0

Versuche dies

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

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

Sie erhalten die Zeile mit dem ersten Vorkommen des gesuchten Textes zurück.

Fernando Chávez
quelle
0

Wenn stringArrayeine große Anzahl von Zeichenfolgen unterschiedlicher Länge enthalten ist, sollten Sie einen Trie zum Speichern und Durchsuchen des Zeichenfolgenarrays verwenden.

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

Hier ist die Implementierung der TrieKlasse

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

Wenn alle Zeichenfolgen stringArraydieselbe Länge haben, ist es besser, wenn Sie nur a HashSetanstelle von a verwendenTrie

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

Einfache Lösung, keine Linq erforderlich

String.Join (",", Array) .Contains (Wert + ",");

user5789849
quelle
2
Was ist, wenn einer der Werte im Array Ihr Trennzeichen enthält?
Tyler Benzing
0
int result = Array.BinarySearch(list.ToArray(), typedString, StringComparer.OrdinalIgnoreCase);
amit jha
quelle
0

Versuchen Sie dies, keine Notwendigkeit für eine Schleife ..

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

}
Amjad Abu Saa
quelle
0

Um die obigen Antworten zu vervollständigen , verwenden Sie für die IgnoreCase- Prüfung Folgendes :

stringArray.Any(s => stringToCheck.IndexOf(s, StringComparison.CurrentCultureIgnoreCase) > -1)
Schattiger Sirhan
quelle
Gibt es auch eine Möglichkeit, den Index des Spiels damit zu erhalten? Vielen Dank.
Si8
0

In meinem Fall haben die obigen Antworten nicht funktioniert. Ich habe in einem Array nach einer Zeichenfolge gesucht und sie einem booleschen Wert zugewiesen. Ich veränderte Antwort des @Anton Gogolev und entfernt , um das Any()Verfahren und setzte die im stringToCheckInnern des Contains()Verfahrens.

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

Verwenden der Find- oder FindIndex- Methoden der Array- Klasse:

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

Ich habe den folgenden Code verwendet, um zu überprüfen, ob die Zeichenfolge eines der Elemente im Zeichenfolgenarray enthält:

foreach (string s in stringArray)
{
    if (s != "")
    {
        if (stringToCheck.Contains(s))
        {
            Text = "matched";
        }
    }
}
Theomax
quelle
3
Dies setzt Text = "matched"so oft, wie stringToCheckTeilzeichenfolgen von enthalten stringArray. Möglicherweise möchten Sie ein breakoder returnnach der Zuweisung setzen.
Dour High Arch
-1

Drei Optionen demonstriert. Ich bevorzuge es, den dritten als den prägnantesten zu finden.

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
quelle
Ihre zweiten beiden Optionen machen beim ersten nicht einmal dasselbe.
Kyle Delaney