C #을 사용하여 문자열 값에 문자열 배열의 단어가 포함되어 있는지 확인하고 싶습니다. 예를 들어

string stringToCheck = "text1text2text3";

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

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

}

'stringToCheck'의 문자열 값에 배열에 단어가 포함되어 있는지 어떻게 확인할 수 있습니까?

당신이 그것을 할 수있는 방법은 다음과 같습니다

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

업데이트 : 더 나은 솔루션을 찾고 있습니까? LINQ를 사용하는 @Anton Gogolev의 답변을 아래에서 참조하십시오.

방법은 다음과 같습니다.

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)

가장 쉽고 샘플 방식.

  bool bol=Array.Exists(stringarray,E => E == stringtocheck);

string strName = "vernie";
string[] strNamesArray = { "roger", "vernie", "joel" };

if (strNamesArray.Any(x => x == strName))
{
   // do some action here if true...
}

아마도 이런 것 :

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

Linq와 메소드 그룹을 사용하는 것이 가장 빠르고 간단한 방법입니다.

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

자신 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();
        }
    }

콘솔 응용 프로그램에서 다음을 사용하여 인수를 확인합니다.

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

Linq를 사용하지만 여전히 다음을 통해 수행 할 수 있습니다.

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

시험:

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

안톤 Gogolev가 있는지 확인하는 있듯이 당신은 또한 같은 일을 할 수있는 모든 항목 에서이 stringArray1일치하는 항목을 에서 stringArray2:

if(stringArray1.Any(stringArray2.Contains))

그리고 마찬가지로 모든 항목 stringArray1에 일치 하는 모든 항목 stringArray2의를 :

if(stringArray1.All(stringArray2.Contains))

stringArray.ToList().Contains(stringToCheck)

여기에 예제를보십시오 : 필드에 배열의 단어가 포함되어 있는지 확인하십시오. field (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;
    }

필자는 Maitrey684의 IndexOf와 비슷한 방법과 Theomax의 foreach 루프를 사용하여 이것을 만들었습니다. (참고 : 처음 3 개의 "문자열"줄은 배열을 만들어 올바른 형식으로 만드는 방법의 예일뿐입니다.)

두 배열을 비교하려면 세미콜론으로 구분되지만 마지막 값에는 그 뒤에 하나가 없습니다. 배열의 문자열 형식에 세미콜론을 추가하면 (예 : 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");

검색된 문자열이 'lines'배열의 요소와 일치하면 bFound가 true로 설정됩니다.

이 시도

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 = '\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;
}

에있는 모든 문자열의 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;
}

linq가 필요없는 간단한 솔루션

String.Join ( ",", array). 포함 (Value + ",");

int result = Array.BinarySearch(list.ToArray(), typedString, StringComparer.OrdinalIgnoreCase);

루프를 할 필요가 없습니다.

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)

제 경우에는 위의 답변이 효과가 없었습니다. 배열에서 문자열을 확인하고 부울 값에 할당했습니다. @Anton Gogolev의 답변을 수정하고 Any()메소드를 제거하고 메소드 stringToCheck내부에 넣었습니다 Contains().

bool = stringArray.Contains(stringToCheck);

Array 클래스 의 Find 또는 FindIndex 메서드 사용

if(Array.Find(stringArray, stringToCheck.Contains) != null) 
{ 
}

if(Array.FindIndex(stringArray, stringToCheck.Contains) != -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();
    }
}