स्ट्रिंग में अंतर C # में तरीकों की तुलना करें

261

C # में स्ट्रिंग की तुलना करना बहुत सरल है। वास्तव में इसे करने के कई तरीके हैं। मैंने नीचे के ब्लॉक में कुछ सूचीबद्ध किए हैं। मैं उन लोगों के बारे में उत्सुक हूं जो उनके बीच मतभेद हैं और जब किसी को दूसरों पर इस्तेमाल किया जाना चाहिए? क्या हर कीमत पर इससे बचना चाहिए? क्या मुझे और सूचीबद्ध नहीं किया गया है?

string testString = "Test";
string anotherString = "Another";

if (testString.CompareTo(anotherString) == 0) {}
if (testString.Equals(anotherString)) {}
if (testString == anotherString) {}

(नोट: मैं इस उदाहरण में समानता की तलाश कर रहा हूं, जो इससे कम या ज्यादा नहीं है लेकिन साथ ही साथ इस पर टिप्पणी करने के लिए स्वतंत्र महसूस कर रहा है)

c# string comparison

— क्रेग
स्रोत

4

एक जाल यह है कि आप stringValue.Equals (अशक्त) नहीं कर सकते हैं क्योंकि यह मानते हैं कि आप null पर एक विधि कह सकते हैं

— johnc

1

MSDN संदर्भ

— रॉबर्ट हार्वे

@RobertHarvey कारण यह है कि मुझे स्टैकओवरफ़्लो आता है इसलिए मुझे उत्तर के लिए कई पृष्ठ नहीं पढ़ने होंगे।

— स्यात्फ़ुल निज़ाम याहया

@ संवेदनशील: कारण मैं ढेर अतिप्रवाह करने के लिए आ रहा है जवाब है कि प्रलेखन में नहीं हैं खोजने के लिए है।

— रॉबर्ट हार्वे

231

ये कार्य कैसे काम करते हैं, इसके लिए यहां नियम दिए गए हैं:

stringValue.CompareTo(otherStringValue)

null एक तार से पहले आता है
यह उपयोग करता है CultureInfo.CurrentCulture.CompareInfo.Compare, जिसका अर्थ है कि यह एक संस्कृति-निर्भर तुलना का उपयोग करेगा। इसका मतलब यह हो सकता है कि जर्मनी में समान या समान की ßतुलना करेंगेSS

stringValue.Equals(otherStringValue)

null किसी भी चीज के बराबर नहीं माना जाता है
जब तक आप एक निर्दिष्ट StringComparisonविकल्प, यह क्या एक सीधा क्रमसूचक समानता की जांच की तरह दिखता है का उपयोग करेगा, यानी ßके समान नहीं है SSकिसी भी भाषा या संस्कृति में,

stringValue == otherStringValue

के रूप में ही नहीं है stringValue.Equals()।
==ऑपरेटर स्थिर कॉल Equals(string a, string b)विधि (जो बारी में एक आंतरिक को जाता है EqualsHelperतुलना करने के लिए।
स्ट्रिंग .Equals()पर कॉल करने पर संदर्भ अपवाद nullमिलता nullहै, जबकि ==ऐसा नहीं होता है।

Object.ReferenceEquals(stringValue, otherStringValue)

बस जाँचता है कि संदर्भ समान हैं, अर्थात यह एक ही सामग्री के साथ सिर्फ दो तार नहीं है, आप अपने साथ एक स्ट्रिंग ऑब्जेक्ट की तुलना कर रहे हैं।

ध्यान दें कि उस विधि कॉल के ऊपर के विकल्पों के साथ, तुलना करने के तरीके को निर्दिष्ट करने के लिए अधिक विकल्पों के साथ ओवरलोड हैं।

मेरी सलाह है कि अगर आप सिर्फ समानता की जांच करना चाहते हैं, तो अपने दिमाग को बनाना है कि आप संस्कृति पर निर्भर तुलना का उपयोग करना चाहते हैं या नहीं, और फिर विकल्प के आधार पर उपयोग करें .CompareToया .Equals।

— लासे वी। कार्लसन
स्रोत

5

"stringValue.Equals (otherStringValue): null शून्य के बराबर नहीं है" Lol, मैं नहीं कहूंगा। अशक्तता ObjectReferenceNotSet अपवाद के बराबर है।

— केविन

29

== के समान नहीं है। ईक्वालस () ... == ऑपरेटर स्टैटिक बराबर (स्ट्रिंग ए, स्ट्रिंग बी) विधि को कॉल करता है (जो बदले में तुलना करने के लिए एक आंतरिक इक्वेल हेल्पर के पास जाता है। कॉलिंग। एक नल पर आता है। स्ट्रिंग को अशक्त संदर्भ प्रकार मिलता है। जबकि == नहीं करता है।

— दान सी।

2

दूसरी ओर, .Equals थोड़ा तेज है (एक कम विधि आंतरिक कॉल), लेकिन कम पठनीय - यकीनन, :)।

— डैन सी।

मैं सोच रहा था '==' संदर्भ तुलना और ऑब्जेक्ट करेगा। असमान मूल्य तुलना करेंगे। कैसे '==' और string.equals समान कार्य करते हैं?

— amesh

@ LasseV.Karlsen पर आपकी क्या राय है String.Compare?

— JDandChips

72

MSDN से:

"कंपेरिटो विधि को मुख्य रूप से सॉर्टिंग या वर्णानुक्रम संचालन में उपयोग के लिए डिज़ाइन किया गया था। इसका उपयोग तब नहीं किया जाना चाहिए जब विधि कॉल का प्राथमिक उद्देश्य यह निर्धारित करना है कि दो तार बराबर हैं। यह निर्धारित करने के लिए कि दो तार बराबर हैं, बराबर विधि को कॉल करें। "

वे समानता के लिए पूरी तरह से देखने के .Equalsबजाय उपयोग करने का सुझाव देते हैं .CompareTo। मैं अगर वहाँ के बीच एक अंतर है यकीन नहीं है .Equalsऔर ==के लिए stringवर्ग। मैं कभी-कभी अपने स्वयं के वर्गों के लिए उपयोग करूंगा .Equalsया Object.ReferenceEqualsइसके बजाय ==यदि कोई बाद में साथ आता है और ==उस वर्ग के लिए ऑपरेटर को फिर से परिभाषित करता है ।

— एड एस।
स्रोत

18

क्या आपके साथ कभी ऐसा हुआ है? (पुनर्परिभाषित ==) ... मैं इसे वायाय भी रक्षात्मक प्रोग्रामिंग के रूप में देखता हूं =)

— जुआन

हां, इसीलिए मैं अब Object.ReferenceEquals का उपयोग करता हूं जब मैं ऑब्जेक्ट समानता की तलाश में हूं :)। यह एक बालक अधिक रक्षात्मक हो सकता है, लेकिन मैं इसके बारे में उन्मत्त नहीं हूं और सच कहूं तो यह स्थिति बहुत बार नहीं आती है।

— एड एस।

मुझे संदेह है कि यह 'रक्षात्मक कोडिंग' उपयोगी है। क्या होगा यदि वर्ग के मालिक को == ऑपरेटर को ओवरराइड करने की आवश्यकता है, तो पता चलता है कि कोई भी इसका उपयोग नहीं कर रहा है?

— डेव वान डेन आईंड

1

@DaveVandenEynde: हाँ ... मैंने इसे कुछ समय पहले लिखा था। मैं इसे नियमित रूप से नहीं करता, केवल ओवरराइडिंग करता हूं।

— एड एस।

1

Microsoft की अनुशंसा यहाँ दर्ज की गई है: .NET फ्रेमवर्क में स्ट्रिंग्स का उपयोग करने के लिए सर्वश्रेष्ठ अभ्यास

— JJS

50

यदि आप BCL के तरीकों में अंतर को लेकर उत्सुक हैं, तो रिफ्लेक्टर आपका मित्र है :-)

मैं इन दिशानिर्देशों का पालन करता हूं:

सटीक मिलान: _{EDIT: मैंने पहले हमेशा इस सिद्धांत पर == ऑपरेटर का उपयोग किया था कि ऑब्जेक्ट के संदर्भ में समतुल्य (स्ट्रिंग, स्ट्रिंग) = = ऑपरेटर का उपयोग वस्तु संदर्भों की तुलना करने के लिए किया जाता है लेकिन ऐसा लगता है कि strA.quals (strB) अभी भी 1-11% है string.Equals (strA, strB), strA == strB और string.CompareOrdinal (strA, strB) की तुलना में तेजी से समग्र। मैं एक ही / अलग स्ट्रिंग लंबाई, और अलग-अलग आकार (1 बी से 5 एमबी) के साथ दोनों इंटर्न / गैर-इंटर्न स्ट्रिंग मानों पर स्टॉपवॉच के साथ परीक्षण किया।}

strA.Equals(strB)

मानव-पठनीय मैच (पश्चिमी संस्कृतियाँ, केस-असंवेदनशील):

string.Compare(strA, strB, StringComparison.OrdinalIgnoreCase) == 0

मानव-पठनीय मैच (अन्य सभी संस्कृतियाँ, असंवेदनशील मामला / उच्चारण / काना / संस्कृति द्वारा परिभाषित)

string.Compare(strA, strB, myCultureInfo) == 0

कस्टम नियमों के साथ मानव-पठनीय मिलान (अन्य सभी संस्कृतियां):

CompareOptions compareOptions = CompareOptions.IgnoreCase
                              | CompareOptions.IgnoreWidth
                              | CompareOptions.IgnoreNonSpace;
string.Compare(strA, strB, CultureInfo.CurrentCulture, compareOptions) == 0

— अधिकतम
स्रोत

18

जैसा कि एड ने कहा, तुलना करने के लिए ComparTo का उपयोग किया जाता है।

हालांकि, बीच का अंतर है। ईक्वल्स और ==।

== मूल रूप से निम्नलिखित कोड का समाधान करता है :

if(object.ReferenceEquals(left, null) && 
   object.ReferenceEquals(right, null))
    return true;
if(object.ReferenceEquals(left, null))
    return right.Equals(left);
return left.Equals(right);

सरल कारण निम्नलिखित है एक अपवाद फेंक देंगे:

string a = null;
string b = "foo";

bool equal = a.Equals(b);

और निम्नलिखित नहीं होगा:

string a = null;
string b = "foo";

bool equal = a == b;

— जोनाथन सी डिकिन्सन
स्रोत

15

स्ट्रिंग तुलनात्मक मुद्दों के बारे में अच्छी व्याख्या और अभ्यास लेख में पाया जा सकता है । Microsoft .NET 2.0 में स्ट्रिंग्स का उपयोग करने के लिए नई सिफारिशें और .NET फ्रेमवर्क में स्ट्रिंग्स का उपयोग करने के लिए सर्वोत्तम व्यवहार में भी ।

उल्लिखित विधि (और अन्य) में से प्रत्येक का विशेष उद्देश्य है। उनके बीच मुख्य अंतर यह है कि StringComparison Enumeration का किस प्रकार वे डिफ़ॉल्ट रूप से उपयोग कर रहे हैं। कई विकल्प हैं:

CurrentCulture
CurrentCultureIgnoreCase
InvariantCulture
InvariantCultureIgnoreCase
क्रमवाचक
OrdinalIgnoreCase

ऊपर दिए गए प्रत्येक प्रकार के लक्ष्य अलग-अलग उपयोग के मामले को लक्षित करते हैं:

क्रमवाचक
- केस-संवेदी आंतरिक पहचानकर्ता
- XML और HTTP जैसे मानकों में केस-संवेदी पहचानकर्ता
- केस-संवेदी सुरक्षा-संबंधी सेटिंग्स
OrdinalIgnoreCase
- केस-असंवेदनशील आंतरिक पहचानकर्ता
- एक्सएमएल और एचटीटीपी जैसे मानकों में केस-असंवेदनशील पहचानकर्ता
- फ़ाइल पथ (Microsoft Windows पर)
- रजिस्ट्री कुंजी / मान
- पर्यावरण चर
- संसाधन पहचानकर्ता (उदाहरण के लिए हैंडल नाम)
- केस असंवेदनशील सुरक्षा संबंधी सेटिंग्स
InvariantCulture या InvariantCultureIgnoreCase
- कुछ ने भाषाई-प्रासंगिक डेटा को बनाए रखा
- भाषाई डेटा का प्रदर्शन एक निश्चित क्रम के लिए आवश्यक है
करंट कल्चर या करंट कल्चर इग्नोरचेज
- उपयोगकर्ता को प्रदर्शित डेटा
- अधिकांश उपयोगकर्ता इनपुट

ध्यान दें, कि स्ट्रिंग तुलना विधियों के लिए StringComparison Enumeration और साथ ही अधिभार, .NET 2.0 के बाद से मौजूद है।

String.CompareTo विधि (स्ट्रिंग)

वास्तव में IComparable.CompareTo विधि का सुरक्षित प्रकार प्रकार है । डिफ़ॉल्ट व्याख्या: CurrentCulture।

उपयोग:

तुलनात्मक रूप से छँटाई या वर्णमाला के संचालन में उपयोग के लिए तुलनात्मक रूप से डिजाइन किया गया था

इस प्रकार

IComparable इंटरफ़ेस को लागू करना आवश्यक रूप से इस पद्धति का उपयोग करेगा

String.Compare विधि

स्ट्रिंग क्लास का एक स्थिर सदस्य जिसमें कई ओवरलोड होते हैं। डिफ़ॉल्ट व्याख्या: CurrentCulture।

जब भी संभव हो, आपको एक तुलना पद्धति का अधिभार कॉल करना चाहिए जिसमें StringComparison पैरामीटर शामिल है।

String.Equals विधि

ऑब्जेक्ट क्लास से ओवरराइड किया गया और टाइप सेफ्टी के लिए ओवरलोड किया गया। डिफ़ॉल्ट व्याख्या: साधारण। नोटिस जो:

स्ट्रिंग श्रेणी की समानता विधियों में स्थिर समतुल्य , स्थिर संचालक == और उदाहरण विधि समतुल्य शामिल हैं ।

StringComparer वर्ग

विशेष रूप से छँटाई करने के लिए स्ट्रिंग तुलनाओं से निपटने का एक और तरीका है:

आप सामान्य संग्रह में तत्वों को सॉर्ट करने के लिए एक विशिष्ट प्रकार की तुलना बनाने के लिए StringComparer वर्ग का उपयोग कर सकते हैं । Hashtable, Dictionary, SortedList, और SortedList जैसी कक्षाएं छँटाई प्रयोजनों के लिए StringComparer वर्ग का उपयोग करती हैं।

— राइजर्ड डिएगन
स्रोत

2

एसओ पर कुछ अन्य पदों के अनुसार, अध्यादेश के अलावा अन्य सभी तरीके ऐसे मामले हैं जहां तुलना (ए, बी) और तुलना (बी), दोनों 1 वापस कर सकते हैं, और बग को वर्गीकृत किया गया है जैसा कि "तय नहीं किया जाएगा" "। जैसे, मुझे यकीन नहीं है कि ऐसी तुलनाओं का कोई उपयोग मामला है।

— सुपरकैट

@ सुपरकार आप उससे लिंक कर सकते हैं, या एक उदाहरण दे सकते हैं?

— नोक्टिस

1

समस्या की चर्चा के लिए stackoverflow.com/questions/17599084/… देखें ।

— सुपरकैट

7

ऐसा नहीं है कि प्रदर्शन आमतौर पर 99% के साथ मायने रखता है जो आपको ऐसा करने की आवश्यकता होती है, लेकिन अगर आपको कई बार लूप में ऐसा करना पड़ता है, तो मैं अत्यधिक सुझाव दूंगा कि आप इसका उपयोग करते हैं। जैसे या == क्योंकि जैसे ही यह एक चरित्र पाता है। यह मेल नहीं खाता है, यह पूरी बात को झूठा करार देता है, लेकिन अगर आप कंपेरिजन का इस्तेमाल करते हैं, तो यह पता लगाना होगा कि कौन सा कैरेक्टर दूसरे से कम है, जिससे परफॉर्मेंस थोड़ी खराब हो जाती है।

यदि आपका ऐप अलग-अलग देशों में चल रहा है, तो मैं सुझाव दूंगा कि आप कल्चरइन्फो के निहितार्थों पर नज़र डालें और संभवतः। चूँकि मैं केवल अमेरिका के लिए ही एप्लिकेशन लिखता हूं (और अगर यह किसी के द्वारा ठीक से काम नहीं करता है) तो मैं हमेशा सिर्फ == का उपयोग करता हूं।

— viggity
स्रोत

5

आपके द्वारा यहां सूचीबद्ध रूपों में, दोनों के बीच बहुत अंतर नहीं है। वर्तमान संस्कृति का उपयोग करके तुलना करने वाली CompareToएक CompareInfoविधि को समाप्त करना ; ऑपरेटर Equalsद्वारा कहा जाता है ==।

यदि आप ओवरलोड पर विचार करते हैं, तो चीजें अलग हो जाती हैं। Compareऔर ==केवल एक स्ट्रिंग की तुलना करने के लिए वर्तमान संस्कृति का उपयोग कर सकते हैं। Equalsऔर String.Compareएक StringComparisonसंज्ञान तर्क ले सकता है जो आपको संस्कृति-असंवेदनशील या केस-असंवेदनशील तुलना निर्दिष्ट करता है। केवल String.Compareआपको CultureInfoडिफ़ॉल्ट संस्कृति के अलावा अन्य संस्कृति का उपयोग करते हुए तुलना करने और प्रदर्शन करने की अनुमति देता है।

इसकी बहुमुखी प्रतिभा के कारण, मुझे लगता है कि मैं String.Compareकिसी भी अन्य तुलना विधि की तुलना में अधिक उपयोग करता हूं ; यह मुझे वही बताता है जो मैं चाहता हूं।

— OwenP
स्रोत

2

नोट करने के लिए एक बड़ा अंतर यह है कि। (पहले स्ट्रिंग अशक्त है, तो एक अपवाद फेंक देगा, जबकि == नहीं होगा।

       string s = null;
        string a = "a";
        //Throws {"Object reference not set to an instance of an object."}
        if (s.Equals(a))
            Console.WriteLine("s is equal to a");
        //no Exception
        if(s==a)
            Console.WriteLine("s is equal to a");

— Rauld
स्रोत

0

s1.CompareTo (s2): प्राथमिक उद्देश्य यह निर्धारित करने के लिए उपयोग नहीं करते कि क्या दो तार बराबर हैं
s1 == s2: मामले को अनदेखा नहीं कर सकता
s1.Equals (s2, StringComparison): यदि N1 शून्य है तो NullReferenceException को फेंकता है
String.Equals (s2, StringComparison): उन्मूलन की प्रक्रिया के द्वारा, यह स्थिर विधि विजेता है (यह निर्धारित करने के लिए एक विशिष्ट उपयोग के मामले को संभालने के लिए कि क्या दो तार बराबर हैं)!

— जॉन डिफिनी
स्रोत

-1

का उपयोग करना। शिक्षा भी पढ़ने के लिए एक बहुत आसान है ।

— hometoast
स्रोत

-9

.Equals के साथ, आप StringComparison विकल्प भी प्राप्त करते हैं। मामले और अन्य चीजों की अनदेखी के लिए बहुत आसान है।

btw, यह गलत का मूल्यांकन करेगा

string a = "myString";
string b = "myString";

return a==b

चूँकि == a और b के मानों की तुलना करता है (जो पॉइंटर्स हैं) यह केवल सत्य का मूल्यांकन करेगा यदि पॉइंटर्स मेमोरी में समान ऑब्जेक्ट को इंगित करते हैं। । पॉइंट्स पॉइंटर्स को डीरेल करता है और पॉइंटर्स पर स्टोर किए गए मानों की तुलना करता है। a.Equals (b) यहाँ सही होगा।

और यदि आप बी को बदलते हैं:

b = "MYSTRING";

तब a.Equals (b) गलत है, लेकिन

a.Equals(b, StringComparison.OrdinalIgnoreCase)

सच होगा

a .CompareTo (b) स्ट्रिंग के तुलनात्मक फ़ंक्शन को कॉल करता है जो पॉइंटर्स और रिटर्न पर मूल्यों की तुलना करता है <0 यदि a पर संग्रहित मूल्य b पर संग्रहीत मान से कम है, तो रिटर्न 0 होता है यदि a.Equals (b) सत्य है, और > 0 अन्यथा। हालाँकि, यह मामला संवेदनशील है, मुझे लगता है कि तुलना और मामले को अनदेखा करने के लिए संभवतः विकल्प हैं, लेकिन अब देखने का समय नहीं है। जैसा कि अन्य पहले ही बता चुके हैं, यह छँटाई के लिए किया जाएगा। इस तरह से समानता के लिए तुलना करने के परिणामस्वरूप आवश्यक ओवरहेड हो जाएगा।

मुझे यकीन है कि मैं सामान बाहर छोड़ रहा हूं, लेकिन मुझे लगता है कि यदि आपको अधिक विवरण की आवश्यकता है तो प्रयोग शुरू करने के लिए यह पर्याप्त जानकारी होनी चाहिए।

— डेविड
स्रोत

9

A == b भाग गलत है। == ऑपरेटर को स्ट्रिंग क्लास के लिए प्रभावी रूप से अधिभारित किया जाता है और यह वास्तविक संदर्भों की परवाह किए बिना मूल्यों की तुलना करता है।

— गोइयिक्स