c# - केस असंवेदनशील 'शामिल है(स्ट्रिंग)'





string contains case-insensitive (21)


OrdinalIgnoreCase, CurrentCultureIgnoreCase या InvariantCultureIgnoreCase?

चूंकि यह गुम है, यहां कुछ सिफारिशें दी गई हैं कि किस का उपयोग करना है:

डॉस

  • संस्कृति-अज्ञेय तार स्ट्रिंग मिलान के लिए अपने सुरक्षित डिफ़ॉल्ट के रूप में तुलना के लिए StringComparison.OrdinalIgnoreCase उपयोग करें।
  • बढ़ी हुई गति के लिए StringComparison.OrdinalIgnoreCaseStringComparison.OrdinalIgnoreCase तुलना का उपयोग करें।
  • उपयोगकर्ता को आउटपुट प्रदर्शित करते समय StringComparison.CurrentCulture-based स्ट्रिंग ऑपरेशंस का उपयोग करें।
  • Non-linguistic StringComparison.Ordinal या StringComparison.OrdinalIgnoreCase का उपयोग करने के लिए इनवेरिएंट संस्कृति के आधार पर स्ट्रिंग ऑपरेशंस के वर्तमान उपयोग को स्विच करें जब तुलना है
    भाषाई रूप से अप्रासंगिक (प्रतीकात्मक, उदाहरण के लिए)।
  • तुलना के लिए तारों को सामान्य करते समय ToUpperInvariant बजाय ToUpperInvariant उपयोग करें।

क्या न करें

  • स्ट्रिंग ऑपरेशंस के लिए ओवरलोड का उपयोग करें जो स्ट्रिंग तुलना तंत्र को स्पष्ट रूप से या स्पष्ट रूप से निर्दिष्ट नहीं करते हैं।
  • StringComparison.InvariantCulture स्ट्रिंग का उपयोग करें
    ज्यादातर मामलों में संचालन; कुछ अपवादों में से एक होगा
    भाषाई रूप से सार्थक लेकिन सांस्कृतिक रूप से अज्ञेयवादी डेटा का पालन करना।

इन नियमों के आधार पर आपको इसका उपयोग करना चाहिए:

string title = "STRING";
if (title.IndexOf("string", 0, StringComparison.[YourDecision]) != -1)
{
    // The string exists in the original
}

जबकि [YourDecision] ऊपर से सिफारिशों पर निर्भर करता है।

स्रोत का लिंक: http://msdn.microsoft.com/en-us/library/ms973919.aspx

क्या निम्नलिखित वापसी सही करने का कोई तरीका है?

string title = "ASTRINGTOTEST";
title.Contains("string");

ऐसा लगता है कि एक अधिभार नहीं है जो मुझे केस संवेदनशीलता सेट करने की इजाजत देता है .. वर्तमान में मैं दोनों को अपरिपक्व करता हूं, लेकिन यह सिर्फ मूर्खतापूर्ण है (जिसके द्वारा मैं i18n मुद्दों का जिक्र कर रहा हूं जो ऊपर और नीचे आवरण के साथ आते हैं)।

अद्यतन करें
यह सवाल प्राचीन है और तब से मुझे एहसास हुआ है कि मैंने वास्तव में विशाल और कठिन विषय के लिए एक सरल उत्तर मांगा है, यदि आप इसकी पूरी तरह जांच कर रहे हैं।
ज्यादातर मामलों के लिए, मोनो-भाषाई में, अंग्रेजी कोड आधार this उत्तर पर्याप्त होगा। मुझे संदेह है क्योंकि यहां आने वाले ज्यादातर लोग इस श्रेणी में आते हैं, यह सबसे लोकप्रिय उत्तर है।
This उत्तर हालांकि अंतर्निहित समस्या को सामने लाता है कि हम टेक्स्ट केस असंवेदनशील की तुलना नहीं कर सकते हैं जब तक हम जानते हैं कि दोनों ग्रंथ समान संस्कृति हैं और हम जानते हैं कि वह संस्कृति क्या है। यह शायद एक कम लोकप्रिय उत्तर है, लेकिन मुझे लगता है कि यह अधिक सही है और इसलिए मैंने इसे इस तरह चिह्नित किया।




आप string.indexof () फ़ंक्शन का उपयोग कर सकते हैं। यह मामला असंवेदनशील होगा




public static class StringExtension
{
    #region Public Methods

    public static bool ExContains(this string fullText, string value)
    {
        return ExIndexOf(fullText, value) > -1;
    }

    public static bool ExEquals(this string text, string textToCompare)
    {
        return text.Equals(textToCompare, StringComparison.OrdinalIgnoreCase);
    }

    public static bool ExHasAllEquals(this string text, params string[] textArgs)
    {
        for (int index = 0; index < textArgs.Length; index++)
            if (ExEquals(text, textArgs[index]) == false) return false;
        return true;
    }

    public static bool ExHasEquals(this string text, params string[] textArgs)
    {
        for (int index = 0; index < textArgs.Length; index++)
            if (ExEquals(text, textArgs[index])) return true;
        return false;
    }

    public static bool ExHasNoEquals(this string text, params string[] textArgs)
    {
        return ExHasEquals(text, textArgs) == false;
    }

    public static bool ExHasNotAllEquals(this string text, params string[] textArgs)
    {
        for (int index = 0; index < textArgs.Length; index++)
            if (ExEquals(text, textArgs[index])) return false;
        return true;
    }

    /// <summary>
    /// Reports the zero-based index of the first occurrence of the specified string
    /// in the current System.String object using StringComparison.InvariantCultureIgnoreCase.
    /// A parameter specifies the type of search to use for the specified string.
    /// </summary>
    /// <param name="fullText">
    /// The string to search inside.
    /// </param>
    /// <param name="value">
    /// The string to seek.
    /// </param>
    /// <returns>
    /// The index position of the value parameter if that string is found, or -1 if it
    /// is not. If value is System.String.Empty, the return value is 0.
    /// </returns>
    /// <exception cref="ArgumentNullException">
    /// fullText or value is null.
    /// </exception>
    public static int ExIndexOf(this string fullText, string value)
    {
        return fullText.IndexOf(value, StringComparison.OrdinalIgnoreCase);
    }

    public static bool ExNotEquals(this string text, string textToCompare)
    {
        return ExEquals(text, textToCompare) == false;
    }

    #endregion Public Methods
}



स्ट्रिंग एक्स्टेंशन क्लास आगे बढ़ने का तरीका है, मैंने एक पूर्ण कोड उदाहरण देने के लिए उपर्युक्त पदों को जोड़ा है:

public static class StringExtensions
{
    /// <summary>
    /// Allows case insensitive checks
    /// </summary>
    public static bool Contains(this string source, string toCheck, StringComparison comp)
    {
        return source.IndexOf(toCheck, comp) >= 0;
    }
}



आप IndexOf() इस तरह उपयोग कर सकते हैं:

string title = "STRING";

if (title.IndexOf("string", 0, StringComparison.CurrentCultureIgnoreCase) != -1)
{
    // The string exists in the original
}

चूंकि 0 (शून्य) एक सूचकांक हो सकता है, तो आप -1 के खिलाफ जांचते हैं।

MSDN

मान की शून्य-आधारित इंडेक्स स्थिति यदि वह स्ट्रिंग पाई जाती है, या -1 यदि यह नहीं है। यदि मान स्ट्रिंग है। लक्षण, वापसी मान 0 है।




.NET कोर 2.0+ केवल (अभी तक)

.NET कोर के संस्करण 2.0 के बाद से निपटने के तरीकों की एक जोड़ी है:

  • स्ट्रिंग। कंटेनर (चार, स्ट्रिंग कॉम्परिसन)
  • स्ट्रिंग। कंटेनेंस (स्ट्रिंग, स्ट्रिंग कॉम्परिसन)

उदाहरण:

"Test".Contains("test", System.StringComparison.CurrentCultureIgnoreCase);

समय के साथ, वे शायद बेस क्लास लाइब्रेरी के सभी अन्य कार्यान्वयन में, .NET मानक और वहां से अपना रास्ता बनायेंगे।




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

string.Compare("string", "STRING", new System.Globalization.CultureInfo("en-US"), System.Globalization.CompareOptions.IgnoreCase);



Regex का उपयोग कर वैकल्पिक समाधान:

bool contains = Regex.IsMatch("StRiNG to search", "string", RegexOptions.IgnoreCase);

नोटिस

जैसा कि @ सीएचओओ ने अपनी टिप्पणी में बताया है, वहां परिदृश्य हैं जो इस समाधान को गलत नतीजे वापस करने का कारण बनेंगे। सुनिश्चित करें कि आप इस समाधान को खतरनाक रूप से लागू करने से पहले क्या कर रहे हैं, यह सुनिश्चित करें।




नौसिखिया के लिए सरल तरीका:

title.ToLower().Contains("string");//of course "string" is lowercase.



ये सबसे आसान समाधान हैं।

  1. इंडेक्स द्वारा

    string title = "STRING";
    
    if (title.IndexOf("string", 0, StringComparison.CurrentCultureIgnoreCase) != -1)
    {
        // contains 
    }
    
  2. मामले बदलकर

    string title = "STRING";
    
    bool contains = title.ToLower().Contains("string")
    
  3. Regex द्वारा

    Regex.IsMatch(title, "string", RegexOptions.IgnoreCase);
    



मुझे पता है कि यह सी # नहीं है, लेकिन ढांचे में (वीबीएनईटी) पहले से ही ऐसा एक समारोह है

Dim str As String = "UPPERlower"
Dim b As Boolean = InStr(str, "UpperLower")

सी # संस्करण:

string myString = "Hello World";
bool contains = Microsoft.VisualBasic.Strings.InStr(myString, "world");



आप हमेशा तारों को पहले ऊपर या नीचे कर सकते हैं।

string title = "string":
title.ToUpper().Contains("STRING")  // returns true

ओह, बस आखिरी बिट देखा। एक मामला असंवेदनशील तुलना * संभवतः वही करेगी, और यदि प्रदर्शन कोई मुद्दा नहीं है, तो मुझे अपरकेस प्रतियां बनाने और उनसे तुलना करने में कोई समस्या नहीं दिखाई दे रही है। मैं शपथ ले सकता था कि मैंने एक बार एक मामले-असंवेदनशील तुलना एक बार देखा ...




आप String.IndexOf विधि का उपयोग कर सकते हैं और स्ट्रिंग कॉम्परिसन पास कर सकते हैं। ऑर्डिनल इग्नोरकेस का उपयोग करने के लिए खोज के प्रकार के रूप में:

string title = "STRING";
bool contains = title.IndexOf("string", StringComparison.OrdinalIgnoreCase) >= 0;

स्ट्रिंग के लिए एक नई एक्सटेंशन विधि को भी परिभाषित करना बेहतर है:

public static class StringExtensions
{
    public static bool Contains(this string source, string toCheck, StringComparison comp)
    {
        return source?.IndexOf(toCheck, comp) >= 0;
    }
}

नोट, वह शून्य प्रचार ?. पुराने संस्करणों के उपयोग के लिए सी # 6.0 (वीएस 2015) के बाद उपलब्ध है

if (source == null) return false;
return source.IndexOf(toCheck, comp) >= 0;

उपयोग:

string title = "STRING";
bool contains = title.Contains("string", StringComparison.OrdinalIgnoreCase);



अगर आप यह जांचना चाहते हैं कि आपकी पास की स्ट्रिंग स्ट्रिंग में है या नहीं तो इसके लिए एक सरल विधि है।

string yourStringForCheck= "abc";
string stringInWhichWeCheck= "Test abc abc";

bool isContaines = stringInWhichWeCheck.ToLower().IndexOf(yourStringForCheck.ToLower()) > -1;

This boolean value will return if string contains or not



परीक्षण करने के लिए कि स्ट्रिंग paragraph में स्ट्रिंग word (धन्यवाद @QuarterMeister)

culture.CompareInfo.IndexOf(paragraph, word, CompareOptions.IgnoreCase) >= 0

जहां culture का उदाहरण है जिस भाषा में लिखा गया है उस भाषा का वर्णन करना।

यह समाधान केस-असंवेदनशीलता की परिभाषा के बारे में पारदर्शी है, जो भाषा निर्भर है । उदाहरण के लिए, अंग्रेजी भाषा नौवीं पत्र के ऊपरी और निचले केस संस्करणों के लिए I और i वर्णों का उपयोग करती है, जबकि तुर्की भाषा इन अक्षरों का उपयोग अपने 2 9 अक्षरों के लंबे वर्णमाला के ग्यारहवें और बारहवें अक्षरों के लिए करती है। 'I' का तुर्की ऊपरी केस संस्करण अपरिचित चरित्र 'İ' है।

इस प्रकार स्ट्रिंग्स tin और TIN अंग्रेजी में एक ही शब्द हैं, लेकिन तुर्की में अलग-अलग शब्द हैं। जैसा कि मैं समझता हूं, एक का अर्थ है 'आत्मा' और दूसरा एक ओनाटोपोपिया शब्द है। (तुर्क, अगर मैं गलत हूं, तो कृपया मुझे सही करें, या बेहतर उदाहरण सुझाएं)

सारांशित करने के लिए, आप केवल प्रश्न का जवाब दे सकते हैं 'क्या ये दो तार समान हैं लेकिन विभिन्न मामलों में' यदि आप जानते हैं कि टेक्स्ट किस भाषा में है । यदि आप नहीं जानते हैं, तो आपको एक पंट लेना होगा। सॉफ़्टवेयर में अंग्रेजी की विरासत को देखते हुए, आपको शायद CultureInfo.InvariantCulture सहारा लेना चाहिए, क्योंकि यह परिचित तरीकों से गलत होगा।




यह साफ और सरल है।

Regex.IsMatch(file, fileNamestr, RegexOptions.IgnoreCase)



सिर्फ इस तरह:

string s="AbcdEf";
if(s.ToLower().Contains("def"))
{
    Console.WriteLine("yes");
}



यहां की चाल स्ट्रिंग को देखने के लिए है, मामले को अनदेखा कर रही है, लेकिन इसे बिल्कुल वही रखने के लिए (उसी मामले के साथ)।

 var s="Factory Reset";
 var txt="reset";
 int first = s.IndexOf(txt, StringComparison.InvariantCultureIgnoreCase) + txt.Length;
 var subString = s.Substring(first - txt.Length, txt.Length);

आउटपुट "रीसेट" है




if ("strcmpstring1".IndexOf(Convert.ToString("strcmpstring2"), StringComparison.CurrentCultureIgnoreCase) >= 0){return true;}else{return false;}



आखिरकार, एक सामान्य "शामिल" ऑपरेशन इस तरह के एक समारोह में आता है,

/// <summary>
/// Determines whether the source contains the sequence.
/// </summary>
/// <typeparam name="T">The type of the items in the sequences.</typeparam>
/// <param name="sourceEnumerator">The source enumerator.</param>
/// <param name="sequenceEnumerator">The sequence enumerator.</param>
/// <param name="equalityComparer">An equality comparer.</param>
/// <remarks>
/// An empty sequence will return <c>true</c>.
/// The sequence must support <see cref="IEnumerator.Reset"/>
/// if it does not begin the source.
/// </remarks>
/// <returns>
/// <c>true</c> if the source contains the sequence;
/// otherwise <c>false</c>.
/// </returns>
public static bool Contains<T>(
    IEnumerator<T> sourceEnumerator,
    IEnumerator<T> sequenceEnumerator,
    IEqualityComparer<T> equalityComparer)
{
    if (equalityComparer == null)
    {
        equalityComparer = EqualityComparer<T>.Default;
    }

    while (sequenceEnumerator.MoveNext())
    {
        if (sourceEnumerator.MoveNext())
        {
            if (!equalityComparer.Equals(
                sourceEnumerator.Current,
                sequenceEnumerator.Current))
            {
                sequenceEnumerator.Reset();
            }
        }
        else
        {
            return false;
        }
    }

    return true;
}

इसे एक विस्तार संस्करण में छोटा रूप से लपेटा जा सकता है जो इस तरह की संख्या को स्वीकार करता है,

public static bool Contains<T>(
        this IEnumerable<T> source,
        IEnumerable<T> sequence,
        IEqualityComparer<T> equalityComparer = null)
{
    if (sequence == null)
    {
        throw new ArgumentNullException("sequence");
    }

    using(var sequenceEnumerator = sequence.GetEnumerator())
    using(var sourceEnumerator = source.GetEnumerator())
    {
        return Contains(
            sourceEnumerator,
            sequenceEnumerator,
            equalityComparer);
    }
}

अब, स्ट्रिंग समेत किसी भी अनुक्रम की क्रमिक तुलना के लिए यह काम करेगा, क्योंकि string लागू करता है IEnumerable<char> ,

// The optional parameter ensures the generic overload is invoked
// not the string.Contains() implementation.
"testable".Contains("est", EqualityComparer<char>.Default)

हालांकि, जैसा कि हम जानते हैं, तार सामान्य नहीं हैं, वे विशिष्ट हैं। खेल में दो महत्वपूर्ण कारक हैं।

  1. "आवरण" मुद्दा जिसमें स्वयं के विभिन्न भाषा निर्भर किनारे हैं।
  2. यूनिकोड कोड पॉइंट्स द्वारा वर्णित "टेक्स्ट एलिमेंट्स" (अक्षरों / संख्याओं / प्रतीकों इत्यादि) का एक सेट किस प्रकार शामिल किया गया है और वर्णों के वैध अनुक्रम एक दिए गए स्ट्रिंग का प्रतिनिधित्व कर सकते हैं, these answers में विवरण विस्तृत किए गए हैं।

शुद्ध प्रभाव वही है। स्ट्रिंग्स जो आप जोर दे सकते हैं भाषाई रूप से बराबर हैं, वर्णों के विभिन्न संयोजनों द्वारा वैध रूप से प्रतिनिधित्व किया जा सकता है। और भी, संस्कृतियों के बीच वैधता के नियम बदल जाते हैं।

यह सब इस तरह के एक विशेष स्ट्रिंग आधारित "युक्त" कार्यान्वयन की ओर जाता है।

using System.Globalization;

public static bool Contains(
         this string source,
         string value,
         CultureInfo culture = null,
         CompareOptions options = CompareOptions.None)
{
    if (value == null)
    {
        throw new ArgumentNullException("value");
    }

    var compareInfo = culture == null ? 
            CultureInfo.CurrentCulture.CompareInfo :
            culture.CompareInfo;

    var sourceEnumerator = StringInfo.GetTextElementEnumerator(source);
    var sequenceEnumerator = StringInfo.GetTextElementEnumerator(value);

    while (sequenceEnumerator.MoveNext())
    {
        if (sourceEnumerator.MoveNext())
        {
            if (!(compareInfo.Compare(
                    sourceEnumerator.Current,
                    sequenceEnumerator.Current,
                    options) == 0))
            {
                sequenceEnumerator.Reset();
            }
        }
        else
        {
            return false;
        }
    }

    return true;
}

इस फ़ंक्शन का उपयोग केस असंवेदनशील, संस्कृति विशिष्ट "युक्त" करने के लिए किया जा सकता है जो काम करेगा, स्ट्रिंग के सामान्यीकरण जो भी हो। जैसे

"testable".Contains("EST", StringComparer.CurrentCultureIgnoreCase)



PHP में, यह सत्यापित करने का सबसे अच्छा तरीका है कि स्ट्रिंग में एक निश्चित सबस्ट्रिंग है, इस तरह एक सरल सहायक फ़ंक्शन का उपयोग करना है:

function contains($haystack, $needle, $caseSensitive = false) {
    return $caseSensitive ?
            (strpos($haystack, $needle) === FALSE ? FALSE : TRUE):
            (stripos($haystack, $needle) === FALSE ? FALSE : TRUE);
}

स्पष्टीकरण:

  • strpos() को एक स्ट्रिंग में केस-सेंसिटिव सबस्ट्रिंग की पहली घटना की स्थिति मिलती है।
  • stripos() को एक स्ट्रिंग में केस-असंवेदनशील सबस्ट्रिंग की पहली घटना की स्थिति मिलती है।
  • myFunction($haystack, $needle) === FALSE ? FALSE : TRUE myFunction($haystack, $needle) === FALSE ? FALSE : TRUE यह सुनिश्चित करता है कि myFunction हमेशा एक बुलियन लौटाता है और अप्रत्याशित व्यवहार को ठीक करता है जब सबस्ट्रिंग की अनुक्रमणिका 0 होती है।
  • $caseSensitive ? A : B $caseSensitive ? A : B $caseSensitive के मूल्य के आधार पर, कार्य करने के लिए या तो stripos() या stripos() का चयन करता है।

आउटपुट:

var_dump(contains('bare','are'));            // Outputs: bool(true)
var_dump(contains('stare', 'are'));          // Outputs: bool(true)
var_dump(contains('stare', 'Are'));          // Outputs: bool(true)
var_dump(contains('stare', 'Are', true));    // Outputs: bool(false)
var_dump(contains('hair', 'are'));           // Outputs: bool(false)
var_dump(contains('aren\'t', 'are'));        // Outputs: bool(true)
var_dump(contains('Aren\'t', 'are'));        // Outputs: bool(true)
var_dump(contains('Aren\'t', 'are', true));  // Outputs: bool(false)
var_dump(contains('aren\'t', 'Are'));        // Outputs: bool(true)
var_dump(contains('aren\'t', 'Are', true));  // Outputs: bool(false)
var_dump(contains('broad', 'are'));          // Outputs: bool(false)
var_dump(contains('border', 'are'));         // Outputs: bool(false)




c# string contains case-insensitive