यदि स्ट्रिंग में स्ट्रिंग स्ट्रिंग में स्ट्रिंग है, तो यह जांचने के लिए C # का उपयोग करना


290

मैं यह जांचने के लिए C # का उपयोग करना चाहता हूं कि क्या स्ट्रिंग मान में एक स्ट्रिंग सरणी में कोई शब्द है। उदाहरण के लिए,

string stringToCheck = "text1text2text3";

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

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

}

मैं कैसे जाँच सकता हूँ कि 'stringToCheck' के स्ट्रिंग मान में कोई शब्द है?


1
यह ब्लॉग परीक्षण के लिए कई तकनीकों का संकेत देता है
रॉबर्ट हार्वे

जवाबों:


145

यहाँ आप इसे कैसे कर सकते हैं:

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

अद्यतन: आप एक बेहतर समाधान की तलाश में हो सकते हैं .. नीचे देखें @Anton Gogolev का उत्तर जो LINQ का उपयोग करता है।


3
धन्यवाद, मैंने आपका कोड संशोधित कर दिया है: यदि (stringToCheck.Contains (s)) और यह काम कर गया।
Theomax

5
मैंने किया था (stringArray.Contains (stringToCheck)) और यह बहुत अच्छा काम करता है, धन्यवाद।
ताम्र JQ

68
इस उत्तर का उपयोग करें LINQ के बजाय
एलेक्सा

11
उन लोगों के लिए थोड़ा ध्यान दें, जिनमें स्ट्रिंग एरे पर कंटेंस विधि नहीं दिखाई देती है : यदि आपके पास "System.Linq" का उपयोग कर रहा है; अपने कोडफाइल में नामस्थान :)
सुधांशु मिश्रा

5
Linq हमेशा विरासत सॉफ्टवेयर में उपलब्ध नहीं है।
विलियम मॉरिसन

842

ऐसे:

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

यह जाँच करता है कि stringToCheckइसमें से कोई एक सबस्ट्रिंग है या नहीं stringArray। यदि आप यह सुनिश्चित करना चाहते हैं कि इसमें सभी सबस्ट्रिंग शामिल हों, तो इसमें बदलाव Anyकरें All:

if(stringArray.All(stringToCheck.Contains))

115
स्वयं पर ध्यान दें: linq अद्भुत है, linq अद्भुत है, linq अद्भुत है! लिटाक का उपयोग करना शुरू कर देंगे।
फ्रेड्रिक जोहानसन

2
@Spooks Linq To ऑब्जेक्ट्स (जो उत्तर के स्ट्रिंग-चेक में उपयोग किया जाता है) को LinqBridge के माध्यम से .NET 2.0 albahari.com/nutshell/linqbridge.aspx
David Rettenbacher

1
आप मामले के प्रतिलोम के साथ यह कैसे करेंगे?
ऑफनर

14
@ ऑफ़लर वह होगाstringArray.Any(s => s.IndexOf(stringToCheck, StringComparison.CurrentCultureIgnoreCase) > -1)
एंटोन

2
सरणी में किस आइटम को कैसे प्राप्त करें?
इबुबी

44

इसे इस्तेमाल करे:

LINQ का उपयोग करने की आवश्यकता नहीं है

if (Array.IndexOf(array, Value) >= 0)
{
    //Your stuff goes here
}

अच्छा! और क्या लाभ हो सकता है Linq संभवतः Array.IndexOf पर हो सकता है ??
Heckflosse_230

21
यह सवाल को हल नहीं करता है। IndexOf आपको बताता है कि क्या किसी सरणी में स्ट्रिंग के लिए एक सटीक मिलान होता है, मूल प्रश्न यह है कि अगर स्ट्रिंग में एक स्ट्रिंग का एक सरणी है, जिसे Linq आसानी से संभालता है।
नेटमैज

मुझे पता है कि यह टिप्पणी देर से है, लेकिन सिर्फ उन लोगों के लिए जो नहीं जानते हैं, एक स्ट्रिंग वर्णों की एक सरणी है इसलिए स्ट्रिंग प्रकारों में एक IndexOf विधि शामिल है ... इसलिए @NetMage यह एक संभव समाधान है।
ब्लैक वुल्फ

3
@ ब्लेकी वुल्फ, क्या आपने प्रश्न पढ़ा है? Array.IndexOf आपको बताता है कि किसी सरणी में मान है या नहीं, ओपी यह जानना चाहता है कि क्या मान में किसी सरणी का कोई सदस्य है या नहीं, इस उत्तर के बिल्कुल विपरीत है। आप Linq के साथ stringArray.Any(w => stringToCheck.IndexOf(w) >= 0)String.IndexOf का उपयोग कर सकते हैं: लेकिन String.Contains का उपयोग करते हुए Linq उत्तर अधिक अर्थ देता है, जैसा कि वास्तव में पूछा जा रहा है।
23

40

बस linq विधि का उपयोग करें:

stringArray.Contains(stringToCheck)

4
ध्यान दें, जिसमें using System.Linq;
सम्‍मिलन

11
यह उत्तर प्रश्न से पीछे की ओर है।
23

2
इस उत्तर को कितनी बार उखाड़ा गया है? सवाल पूछे जाने के 5 साल बाद और समाधान मूल रूप से उलट है कि सवाल क्या पूछ रहा है।
फुस रो दाह

1
शायद चर नामों को उलट दें, यह ठीक होगा?
जीन फ़्राँस्वा Fabre

8

सबसे आसान और नमूना तरीका है।

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

बेहतर स्ट्रिंगर है। एक्सिस्ट्स (एंटिटी => एंटिटी == स्ट्रीटोचेक)
मार्सेल ग्रुगर

मुझे लगता है कि आप नहीं कर सकते कॉल स्ट्रिंग array.Exists से सीधे विधि मौजूद है विधि सूची के लिए सीधे उपयोग कर सकते हैं <टी> तो array.exist <टी> स्ट्रिंग के लिए यहाँ => array.check स्थिर विधि का उपयोग करना चाहिए 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...
}

2
मुझे नहीं लगता कि यह वही सवाल है जो पूछ रहा है।
पेंग

5

कुछ इस तरह शायद:

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.Containsकी तुलना में बेहतर हो सकता है String.IndexOfजब तक कि आप मामले को अनदेखा करना चाहते हैं, क्योंकि माइक्रोसॉफ्ट एक दो तर्क भूल गया String.Containsआप अपने खुद के बारे में जाना है। विचार करें:Array.Exists(stringArray, s => stringToCheck.IndexOf(s, StringComparison.OrdinalIgnoreCase) > -1)
NetMage

3

Linq और विधि समूह का उपयोग करना ऐसा करने का सबसे तेज और अधिक कॉम्पैक्ट तरीका होगा।

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

3

आप अपने खुद के 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();
        }
    }

2

मैं तर्कों के लिए जाँच करने के लिए कंसोल एप्लिकेशन में निम्नलिखित का उपयोग करता हूं

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

2

मैं Linq का उपयोग करेगा, लेकिन यह अभी भी किया जा सकता है:

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

1

प्रयत्न:

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

1

एंटोन Gogolev अगर जाँच करने के लिए पता चलता है के रूप में आप यह भी एक ही बात कर सकते हैं किसी भी आइटम में stringArray1से मेल खाता है किसी भी आइटम में stringArray2:

if(stringArray1.Any(stringArray2.Contains))

और इसी तरह सभी आइटम stringArray1 में मेल खाते हैं सभी आइटम stringArray2 में:

if(stringArray1.All(stringArray2.Contains))


0

यह कोशिश करें, यहां उदाहरण: यह जांचने के लिए कि फ़ील्ड में सरणी में कोई शब्द है या नहीं। यह जाँचने के लिए कि फ़ील्ड (someField) में किसी भी शब्द को सरणी में रखा गया है या नहीं।

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

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

someFieldFilter = i => val.Any(s => i.someField.Contains(s));

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

0

मैंने इसे बनाने के लिए Maitrey684 द्वारा IndexOf और Theomax के फोरच लूप के समान विधि का उपयोग किया। (नोट: पहली 3 "स्ट्रिंग" लाइनें इस बात का एक उदाहरण हैं कि आप एक सरणी कैसे बना सकते हैं और इसे उचित प्रारूप में प्राप्त कर सकते हैं)।

यदि आप 2 सरणियों की तुलना करना चाहते हैं, तो वे अर्ध-बृहदान्त्र सीमांकित होंगे, लेकिन अंतिम मान इसके बाद एक नहीं होगा। यदि आप एक अर्ध-बृहदान्त्र को सरणी के स्ट्रिंग रूप में जोड़ते हैं (यानी; ए; बी; सी एक; बी; सी;) बन जाता है, तो आप "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) { 
    // ....
}

0
string [] lines = {"text1", "text2", "etc"};

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

अगर खोज स्ट्रिंग 'लाइनों' के किसी भी तत्व के साथ मेल खाता है तो bFound सेट सही है।


0

इसे इस्तेमाल करे

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

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

यह आपको उस पाठ की पहली घटना के साथ लाइन लौटाएगा जिसे आप खोज रहे हैं।


0

यदि stringArrayबड़ी संख्या में विभिन्न स्ट्रिंग्स हैं, तो स्ट्रिंग सरणी को संग्रहीत करने और खोजने के लिए एक ट्राइ का उपयोग करने पर विचार करें।

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

0

सरल समाधान, किसी भी linq की आवश्यकता नहीं है

स्ट्रिंग। जॉइन (",", एरे)। कॉन्टेक्ट्स (वैल्यू + ",");


2
यदि सरणी में किसी एक मान में आपका सीमांकक है तो क्या होगा?
टायलर बेंज़िंग


0

यह कोशिश करो, लूप की कोई ज़रूरत नहीं है ।।

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

}

0

उपरोक्त उत्तरों को पूरा करने के लिए, IgnoreCase चेक उपयोग के लिए:

stringArray.Any(s => stringToCheck.IndexOf(s, StringComparison.CurrentCultureIgnoreCase) > -1)

क्या इसके साथ मैच का सूचकांक प्राप्त करने का कोई तरीका है? धन्यवाद।
Si8

0

मेरे मामले के लिए, उपरोक्त उत्तर काम नहीं आया। मैं एक स्ट्रिंग में स्ट्रिंग के लिए जाँच कर रहा था और इसे बूलियन मान पर नियत कर रहा था। मैंने @ एटन गोगोलेव के उत्तर को संशोधित किया और Any()विधि को हटा दिया और stringToCheckअंदर की Contains()विधि डाल दी ।

bool = stringArray.Contains(stringToCheck);


-1

यदि स्ट्रिंग स्ट्रिंग में कोई भी आइटम सम्‍मिलित है, यह जांचने के लिए मैंने निम्नलिखित कोड का उपयोग किया:

foreach (string s in stringArray)
{
    if (s != "")
    {
        if (stringToCheck.Contains(s))
        {
            Text = "matched";
        }
    }
}

3
यह Text = "matched"कई बार के रूप stringToCheckमें के रूप में substrates के सेट करता है stringArray। आप असाइनमेंट के बाद breakया returnउसके बाद रखना चाह सकते हैं ।
डोर हाई आर्क

-1

तीन विकल्पों का प्रदर्शन किया। मैं तीसरे को सबसे संक्षिप्त रूप में ढूंढना पसंद करता हूं।

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

आपके दूसरे दो विकल्प भी पहले एक ही काम नहीं करते हैं।
काइल डेलानी
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.