दिलचस्प पोस्ट
पायथन की स्ट्रिंग कंसैक्शन बनाम str.join कैसे धीमा है? एंड्रॉइड सेवा से चेतावनी संवाद मैं एपीआई के माध्यम से गूगल ड्राइव पर फाइल कैसे बना / बना / डालने करूँ? अनंत रिकर्सन के बिना मैं '==' ऑपरेटर ओवरलोड में नल के लिए कैसे जांचूं? यह जाँचने का सबसे अच्छा तरीका क्या है कि कोई URL PHP में मौजूद है या नहीं? सी में दो दशमलव स्थानों को गोलाई संख्या इनलाइन और ब्लॉक कोड स्निपेट के लिए <code> बनाम <पूर्व> बनाम <samp> मैं कैसे जांच सकता हूं कि जावा में दो नंबरों को गुणा करना ओवरफ़्लो का कारण होगा? संसाधन (.resx) फ़ाइलों के लाभ क्या हैं? सी (और अन्य मामले में वे संगत हैं) में पूर्ण "के लिए" लूप सिंटैक्स क्या है? फोन को जल्दी से 180 डिग्री घूमते हुए कैमरा पूर्वावलोकन उल्टा हो जाता है PHP घातक त्रुटि: ऑब्जेक्ट संदर्भ में नहीं होने पर $ का उपयोग करना ड्रॉपबॉक्स के साथ गिट क्या रैवल्यू संदर्भ से अधिक कुशलता वापस आ रही है? कैसे बास में एक आदेश से आउटपुट में एक चर सेट करने के लिए?

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

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

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

ऐसा लगता नहीं एक अधिभार है कि मुझे मामले की संवेदनशीलता सेट करने की अनुमति देता है .. वर्तमान में मैं उन दोनों को ऊपर की तरफ बढ़ा देता हूं, लेकिन यह सिर्फ मूर्खतापूर्ण है।

अद्यतन करें
मैं जिस मूर्खता का उल्लेख करता हूं वह i18n मुद्दे हैं जो ऊपर और नीचे आवरण के साथ आते हैं।

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

वेब के समाधान से एकत्रित समाधान "केस असंवेदनशील 'शामिल (स्ट्रिंग)'"

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

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

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

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

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

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

आप 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; } } ... string title = "STRING"; bool contains = title.Contains("string", StringComparison.OrdinalIgnoreCase); 

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

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

चूंकि 0 (शून्य) एक सूचकांक हो सकता है, आप 1 के विरुद्ध जांच करते हैं I

MSDN

मान की शून्य-आधारित सूचकांक स्थिति अगर वह स्ट्रिंग मिली है, या -1 यदि नहीं है। अगर मान स्ट्रिंग है। खाली, रिटर्न वैल्यू 0 है

रेगेक्स का वैकल्पिक समाधान:

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

नोटिस

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

आप हमेशा तारों को ऊपर या डाउन कर सकते हैं पहले

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

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

जवाब के साथ एक मुद्दा यह है कि यदि कोई स्ट्रिंग रिक्त है तो यह एक अपवाद फेंक देगा। आप इसे एक चेक के रूप में जोड़ सकते हैं, इसलिए यह नहीं होगा:

 public static bool Contains(this string source, string toCheck, StringComparison comp) { if (string.IsNullOrEmpty(toCheck) || string.IsNullOrEmpty(source)) return true; return source.IndexOf(toCheck, comp) >= 0; } 

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

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

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

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

OrdinalIgnoreCase, CurrentCultureIgnoreCase या InvariantCultureIgnoreCase?

चूंकि यह अनुपलब्ध है, यहां कुछ सुझाव दिए गए हैं कि किसका उपयोग करना है:

डॉस

  • स्ट्रिंग StringComparison.OrdinalIgnoreCase उपयोग करें। StringComparison.OrdinalIgnoreCase , संस्कृति के अज्ञात स्ट्रिंग मिलान के लिए आपके सुरक्षित डिफ़ॉल्ट के रूप में तुलना के लिए।
  • StringComparison.OrdinalIgnoreCase उपयोग करें। StringComparison.OrdinalIgnoreCase वृद्धि की गति के लिए तुलना
  • उपयोगकर्ता को आउटपुट प्रदर्शित करते समय StringComparison.CurrentCulture-based स्ट्रिंग ऑपरेशन का उपयोग करें।
  • गैर भाषाई स्ट्रिंग कॉमपारिसन का उपयोग करने के लिए अपरिवर्तनीय संस्कृति के आधार पर स्ट्रिंग ऑपरेशन का वर्तमान उपयोग स्विच करें। StringComparison.Ordinal या स्ट्रिंग 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 s="AbcdEf"; if(s.ToLower().Contains("def")) { Console.WriteLine("yes"); } 

मुझे पता है कि यह सी # नहीं है, लेकिन रूपरेखा (वीबी। नेट) में पहले से ही ऐसा फ़ंक्शन मौजूद है

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

सी # संस्करण:

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

VisualBasic विधानसभा से InStr विधि सबसे अच्छा है अगर आपको अंतर्राष्ट्रीयकरण के बारे में कोई चिंता है (या आप इसे पुनःपूर्ति कर सकते हैं)। इसे देखकर dotNeetPeek दिखाता है कि न केवल यह टोपी और लोअरकेस के लिए खाता है, बल्कि काना प्रकार और पूर्ण-बनाम आधा-चौथाई वर्ण (एशियाई भाषाओं के लिए अधिकतर प्रासंगिक) के लिए भी, हालांकि रोमन वर्णमाला के पूर्ण-चौड़े संस्करण भी हैं )। मैं कुछ विवरणों को लंघन कर रहा हूँ, लेकिन निजी पद्धति InternalInStrText :

 private static int InternalInStrText(int lStartPos, string sSrc, string sFind) { int num = sSrc == null ? 0 : sSrc.Length; if (lStartPos > num || num == 0) return -1; if (sFind == null || sFind.Length == 0) return lStartPos; else return Utils.GetCultureInfo().CompareInfo.IndexOf(sSrc, sFind, lStartPos, CompareOptions.IgnoreCase | CompareOptions.IgnoreKanaType | CompareOptions.IgnoreWidth); } 

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

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

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

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

यह इस तरह IEnumerable स्वीकार करने के एक विस्तार संस्करण में तुच्छ में लपेटा जा सकता है,

 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. इसके बजाय, "पाठ तत्वों" (अक्षरों / संख्याओं / प्रतीकों आदि) का एक समूह यूनिकोड कोड अंकों का एक समूह कैसे दिखाता है और वर्णों के कौन से मान्य अनुक्रम किसी दिए गए स्ट्रिंग का प्रतिनिधित्व कर सकते हैं, इन उत्तरों में इन विवरणों का विस्तार किया गया है ।

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

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

 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) 

यह अन्य उदाहरणों के समान है, लेकिन मैंने प्राथमिक रूप से इनाम को सरल बनाने का निर्णय लिया है क्योंकि प्राथमिक रूप से अन्य विकल्पों की आवश्यकता नहीं है। यहां मेरा उदाहरण है:

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

और उपयोग कुछ ऐसा है:

 if( "main String substring".Contains("SUBSTRING", true) ) .... 

ऐसा करने के लिए एक RegEx का उपयोग करना एक सीधा तरीका है:

 Regex.IsMatch(title, "string", RegexOptions.IgnoreCase); 
 if ("strcmpstring1".IndexOf(Convert.ToString("strcmpstring2"), StringComparison.CurrentCultureIgnoreCase) >= 0){return true;}else{return false;} 

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

यहां की चाल स्ट्रिंग की तलाश करने के लिए, मामले की अनदेखी करना है, लेकिन इसे समान रूप से रखने के लिए (उसी मामले में)।

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

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

 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 } 

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

 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 

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

 title.Contains("string") || title.Contains("string".ToUpper());