केस असंवेदनशील स्ट्रिंग तुलना कैसे करें?

1056

मैं जावास्क्रिप्ट में केस की असंवेदनशील स्ट्रिंग की तुलना कैसे करूँ?

javascript  string 
— तारों से उड़ना
स्रोत
25
नई गयी .localeCompare()जावास्क्रिप्ट विधि देखें। केवल आधुनिक ब्राउज़रों द्वारा लिखित (IE11 +) के समय समर्थित है। देखें डेवलपर.
— mozilla.org/en-US/docs/Web/JavaScript/Reference/…
1
यह भी देखें stackoverflow.com/questions/51165/…
— Adrien Be
5
@ AdrienBe Chrome 48 कंसोल में "A".localeCompare( "a" );लौटता 1है।
— मनुवेल २५'१६ को
3
@manuell जिसका अर्थ "a"है छांटने से पहले आता है "A"। जैसा "a"पहले आता है "b"। यदि यह व्यवहार नहीं चाहता है, तो .toLowerCase()प्रत्येक पत्र / स्ट्रिंग को चाह सकता है । अर्थात। developer.mozilla.org/en/docs/Web/JavaScript/Reference/…"A".toLowerCase().localeCompare( "a".toLowerCase() ) देखें
— Adrien Be
2
क्योंकि तुलना अक्सर एक ऐसा शब्द है जिसका इस्तेमाल मैं छंटाई / छंटनी के आदेश के लिए करता हूं। मैंने बहुत समय पहले यहां टिप्पणी की थी। ===समानता के लिए जाँच करेगा लेकिन स्ट्रिंग्स / ऑर्डरिंग स्ट्रिंग्स (cf. प्रश्न मैं मूल रूप से जुड़ा हुआ है) के लिए पर्याप्त नहीं होगा।
— बी

जवाबों:

1161

इसे करने का सबसे सरल तरीका (यदि आप विशेष यूनिकोड वर्णों के बारे में चिंतित नहीं हैं) तो कॉल करना है toUpperCase:

var areEqual = string1.toUpperCase() === string2.toUpperCase();
— SLaks
स्रोत
44
ऊपरी या निचले मामले में रूपांतरण सभी भाषाओं में सही मामले असंवेदनशील तुलना प्रदान करता है। i18nguy.com/unicode/tuki-i18n.html
— सैमुअल नेफ
57
@ एसम: मुझे पता है। इसलिए मैंने लिखा है if you're not worried about special Unicode characters।
— SLACs
141
वहाँ पसंद करते हैं करने के लिए एक कारण है toUpperCaseके ऊपर toLowerCase?
— jpmc26
137
— SLaks
19
क्या यह वास्तव में सबसे अच्छा जेएस की पेशकश है?
— कुगेल
210

EDIT : यह उत्तर मूल रूप से 9 साल पहले जोड़ा गया था। आज आपको विकल्प के localeCompareसाथ उपयोग करना चाहिए sensitivity: 'accent':

function ciEquals(a, b) {
    return typeof a === 'string' && typeof b === 'string'
        ? a.localeCompare(b, undefined, { sensitivity: 'accent' }) === 0
        : a === b;
}

console.log("'a' = 'a'?", ciEquals('a', 'a'));
console.log("'AaA' = 'aAa'?", ciEquals('AaA', 'aAa'));
console.log("'a' = 'á'?", ciEquals('a', 'á'));
console.log("'a' = 'b'?", ciEquals('a', 'b'));
स्निपेट का विस्तार करें

{ sensitivity: 'accent' }बताता है localeCompare()एक ही रूप में एक ही आधार पत्र के दो वेरिएंट के इलाज के लिए जब तक ऊपर वे अलग अलग उच्चारण चिह्न (तीसरा उदाहरण के रूप में)।

वैकल्पिक रूप से, आप उपयोग कर सकते हैं { sensitivity: 'base' }, जो दो वर्णों को तब तक समान मानता है जब तक उनका आधार वर्ण समान होता है (इसलिए Aइसे समतुल्य माना जाएगा á)।

ध्यान दें कि localeCompareIE10 या उससे कम या निश्चित मोबाइल ब्राउज़रों में तीसरा पैरामीटर समर्थित नहीं है (ऊपर दिए गए पृष्ठ पर संगतता चार्ट देखें), इसलिए यदि आपको उन ब्राउज़रों का समर्थन करने की आवश्यकता है, तो आपको किसी प्रकार की गिरावट की आवश्यकता होगी:

function ciEqualsInner(a, b) {
    return a.localeCompare(b, undefined, { sensitivity: 'accent' }) === 0;
}

function ciEquals(a, b) {
    if (typeof a !== 'string' || typeof b !== 'string') {
        return a === b;
    }

    //      v--- feature detection
    return ciEqualsInner('A', 'a')
        ? ciEqualsInner(a, b)
        : /*  fallback approach here  */;
}

मूल उत्तर

जावास्क्रिप्ट में असंवेदनशील तुलना केस करने का सबसे अच्छा तरीका है match(), iझंडा के साथ RegExp विधि का उपयोग करना ।

केस-असंवेदनशील खोज

जब दोनों तारों की तुलना की जा रही है तो चर (स्थिरांक नहीं) हैं, तो यह थोड़ा अधिक जटिल है, क्योंकि आपको स्ट्रिंग से एक RegExp उत्पन्न करने की आवश्यकता है, लेकिन स्ट्रिंग को RegExp कंस्ट्रक्टर में भेजने से गलत मिलान या असफल मैच हो सकते हैं यदि स्ट्रिंग विशेष regex है इसमें वर्ण।

यदि आप अंतर्राष्ट्रीयकरण के बारे में परवाह नहीं करते हैं toLowerCase()या toUpperCase()इसका उपयोग नहीं करते हैं, तो यह सभी भाषाओं में सटीक केस-असंवेदनशील तुलना प्रदान नहीं करता है।

http://www.i18nguy.com/unicode/turkish-i18n.html

— सैमुअल नेफ
स्रोत
5
@ प्रश्न, हाँ, यही मैंने कहा था कि - "आपको स्ट्रिंग से एक RegExp उत्पन्न करने की आवश्यकता है लेकिन RegExp निर्माता को स्ट्रिंग पास करने से गलत मिलान या विफल मैच हो सकते हैं यदि स्ट्रिंग में विशेष रेगेक्स वर्ण हैं"
— शमूएल नेफ
21
इसका उपयोग केस-असंवेदनशील स्ट्रिंग तुलना के लिए सबसे महंगा समाधान है। एक RegExp जटिल पैटर्न मिलान के लिए होता है, जैसे कि, इसे प्रत्येक पैटर्न के लिए एक निर्णय ट्री बनाने की आवश्यकता होती है, फिर लॉकिंग के खिलाफ निष्पादन करता है। जबकि यह काम करेगा, यह अगले ब्लॉक पर खरीदारी करने के लिए एक जेट विमान लेने के लिए तुलनीय है। tl; dr: कृपया ऐसा न करें।
— अगस्टोन होर्वाथ
2
मैं localeCompare () का उपयोग कर सकता था, लेकिन इसकी वापसी -1 के लिए 'a'.localeCompare('A')और सेशन की तरह मैं केस असंवेदनशील स्ट्रिंग तुलना की तलाश में हूं।
— स्टिंगजैक
3
@StingyJack केस-असंवेदनशील करने के लिए localeCompare का उपयोग करके तुलना करें, आपको 'a'.localeCompare (' A ', अपरिभाषित, {संवेदनशीलता:' आधार '}) करना चाहिए
— जुडाह गेब्रियल हिमेल
1
नोट:localeCompare संस्करण है कि JavaScript इंजन समर्थन की आवश्यकता है ECMAScript® अंतर्राष्ट्रीयकरण एपीआई है, जो यह है नहीं करने के लिए आवश्यक। इसलिए इस पर भरोसा करने से पहले, आप यह जांचना चाहेंगे कि यह आपके द्वारा उपयोग किए जा रहे वातावरण में काम करता है या नहीं। उदाहरण के लिए: const compareInsensitive = "x".localeCompare("X", undefined, {sensitivity: "base"}) === 0 ? (a, b) => a.localeCompare(b, undefined, {sensitivity: "base"}) : (a, b) => a.toLowerCase().localeCompare(b.toLowerCase());या कुछ ऐसे।
— टीजे क्राउडर
46

जैसा कि हाल की टिप्पणियों में कहा गया है, string::localeCompareकेस असंवेदनशील तुलना (अन्य शक्तिशाली चीजों के बीच) का समर्थन करता है।

यहाँ एक सरल उदाहरण है

'xyz'.localeCompare('XyZ', undefined, { sensitivity: 'base' }); // returns 0

और एक सामान्य फ़ंक्शन जिसका आप उपयोग कर सकते हैं

function equalsIgnoringCase(text, other) {
    return text.localeCompare(other, undefined, { sensitivity: 'base' }) === 0;
}

ध्यान दें कि आपके बजाय undefinedशायद उस विशिष्ट स्थान में प्रवेश करना चाहिए जिसके साथ आप काम कर रहे हैं। यह MDN डॉक्स में चिह्नित के रूप में महत्वपूर्ण है

स्वीडिश में, ä और एक अलग आधार पत्र हैं

संवेदनशीलता के विकल्प

एमडीएन से संवेदनशीलता विकल्प

ब्राउज़र का समर्थन

पोस्टिंग के समय तक, एंड्रॉइड और ओपेरा मिनी के लिए यूसी ब्राउज़र लोकेल और विकल्प मापदंडों का समर्थन नहीं करता है । कृपया अद्यतित जानकारी के लिए https://caniuse.com/#search=localeCompare देखें ।

— जय विक
स्रोत
35

नियमित अभिव्यक्ति की मदद से भी हम प्राप्त कर सकते हैं।

(/keyword/i).test(source)

/iमामले को अनदेखा करने के लिए है। यदि आवश्यक नहीं है तो हम इस तरह के संवेदनशील मामले की तरह अनदेखा नहीं कर सकते हैं

(/keyword/).test(source)
— SP007
स्रोत
17
इस तरह एक regex का उपयोग substrings मैच होगा! आपके उदाहरण में स्ट्रिंग keyWORDएक सकारात्मक मैच में परिणाम लाएगा। लेकिन स्ट्रिंग this is a keyword yoया keywordsएक सकारात्मक मैच भी होगा। उस के बारे में पता होना :-)
— एल्मर
6
यह सवाल में पूछे गए समानता चेक (केस असंवेदनशील) का जवाब नहीं देता है! लेकिन, यह एक कंटीन्यू चेक है! इसका उपयोग न करें
— S.Serpooshan
4
बेशक, पूरे स्ट्रिंग से मेल खाने के लिए, रेग्जैक्स को बदल दिया जा सकता है /^keyword$/.test(source), लेकिन 1) यदि keywordकोई स्थिरांक नहीं है, तो आपको ऐसा करने की आवश्यकता होगी new RegExp('^' + x + '$').test(source)और 2) केस-असंवेदनशील स्ट्रिंग समानता के रूप में कुछ का परीक्षण करने के लिए एक regexp का सहारा लेना होगा। बहुत कुशल नहीं है।
— जेएचएच
28

याद रखें कि आवरण एक स्थानीय विशिष्ट ऑपरेशन है। परिदृश्य के आधार पर आप इसे खाते में लेना चाहते हैं। उदाहरण के लिए, यदि आप उन दो लोगों के नामों की तुलना कर रहे हैं, जिन पर आप स्थानीय विचार करना चाहते हैं, लेकिन यदि आप मशीन से उत्पन्न मूल्यों जैसे कि यूयूआईडी की तुलना कर रहे हैं, तो आप नहीं कर सकते। यह मैं अपने बर्तन पुस्तकालय में निम्नलिखित फ़ंक्शन का उपयोग करता हूं (ध्यान दें कि टाइपिंग की जाँच प्रदर्शन के कारण शामिल नहीं है)।

function compareStrings (string1, string2, ignoreCase, useLocale) {
    if (ignoreCase) {
        if (useLocale) {
            string1 = string1.toLocaleLowerCase();
            string2 = string2.toLocaleLowerCase();
        }
        else {
            string1 = string1.toLowerCase();
            string2 = string2.toLowerCase();
        }
    }

    return string1 === string2;
}
— शीतल शाह
स्रोत
क्या कोई कारण है जिसका आप उपयोग करते हैं "!!" मानों की सत्यता का मूल्यांकन करने के लिए यदि क्लॉज की अनुमति देने के बजाय एक स्पष्ट बूलियन रूपांतरण करने के लिए?
— सेलोस
इसकी आवश्यकता नहीं है। मुझे लगता है कि मेरे पास अधिक जटिल कोड के मेरे दूसरे संस्करण से था। मैंने जवाब अपडेट कर दिया है।
— शीतल शाह
@thekodester आपके फ़ंक्शन में एक बग है। यह इस तथ्य के बावजूद compareStrings("", "")देगा falseकि तार बराबर हैं।
— सर्गेई
@ सेर्गेई कर रही है कि trueमेरे लिए रिटर्न । शायद यह आपके ब्राउज़र के साथ एक बग है?
— जेना स्लोन
14

मैंने हाल ही में एक माइक्रो लाइब्रेरी बनाई है जो केस-असंवेदनशील स्ट्रिंग हेल्पर्स प्रदान करती है: https://github.com/nickuraltsev/ignore-case । (यह toUpperCaseआंतरिक रूप से उपयोग करता है ।)

var ignoreCase = require('ignore-case');

ignoreCase.equals('FOO', 'Foo'); // => true
ignoreCase.startsWith('foobar', 'FOO'); // => true
ignoreCase.endsWith('foobar', 'BaR'); // => true
ignoreCase.includes('AbCd', 'c'); // => true
ignoreCase.indexOf('AbCd', 'c'); // => 2
— निक यूराल्टसेव
स्रोत
12

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

function my_strcasecmp( a, b ) 
{
    if((a+'').toLowerCase() > (b+'').toLowerCase()) return 1  
    if((a+'').toLowerCase() < (b+'').toLowerCase()) return -1
    return 0
}

जावास्क्रिप्ट स्ट्रिंग स्ट्रिंग तुलना के लिए लोकेल "सी" का उपयोग करता है, इसलिए परिणामस्वरूप ऑर्डरिंग बदसूरत होगी यदि तार में ASCII अक्षरों के अलावा अन्य होते हैं। स्ट्रिंग्स का अधिक विस्तृत निरीक्षण किए बिना इसके बारे में बहुत कुछ नहीं किया जा सकता है।

— Jasen
स्रोत
7

मान लीजिए कि हम स्ट्रिंग चर needleमें स्ट्रिंग चर खोजना चाहते हैं haystack। तीन गोत्र हैं:

  1. अंतर्राष्ट्रीय अनुप्रयोगों से बचना चाहिए string.toUpperCaseऔर string.toLowerCase। एक नियमित अभिव्यक्ति का उपयोग करें जो मामले के बजाय उपेक्षा करता है। उदाहरण के लिए, var needleRegExp = new RegExp(needle, "i");इसके बाद needleRegExp.test(haystack)।
  2. सामान्य तौर पर, आप के मूल्य को नहीं जान सकते हैं needle। सावधान रहें कि needleइसमें कोई नियमित अभिव्यक्ति विशेष वर्ण नहीं है । इन का उपयोग करके बच needle.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");।
  3. अन्य मामलों में, यदि आप ठीक से मिलान करना चाहते हैं needleऔर haystack, केवल मामले को अनदेखा कर रहे हैं "^", तो शुरुआत में और "$"अपने नियमित अभिव्यक्ति परीक्षक के अंत में जोड़ना सुनिश्चित करें ।

अंक (1) और (2) को ध्यान में रखते हुए, एक उदाहरण होगा: 

var haystack = "A. BAIL. Of. Hay.";
var needle = "bail.";
var needleRegExp = new RegExp(needle.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), "i");
var result = needleRegExp.test(haystack);
if (result) {
    // Your code here
}
— क्रिस च्यूट
स्रोत
बिलकुल! तुम सब करने की ज़रूरत है की जगह है new RegExp(...)निम्नलिखित के साथ लाइन 3 में भाग: new RegExp("^" + needle.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&") + "$", "i");। यह सुनिश्चित करता है कि आपके खोज स्ट्रिंग से पहले या बाद में कोई अन्य वर्ण नहीं हैं needle।
— क्रिस च्यूट
4

केस असंवेदनशील तुलना के दो तरीके हैं:

  1. स्ट्रिंग्स को ऊपरी केस में कनवर्ट करें और फिर सख्त ऑपरेटर ( ===) का उपयोग करके उनकी तुलना करें । ऑपरेटर कितना सख्त व्यवहार करता है, इस पर सामान पढ़ता है: http://www.thesstech.com/javascript/relational-logical-operators
  2. स्ट्रिंग विधियों का उपयोग करते हुए पैटर्न मिलान:

केस असंवेदनशील खोज के लिए "खोज" स्ट्रिंग विधि का उपयोग करें। खोज और अन्य स्ट्रिंग विधियों के बारे में यहाँ पढ़ें: http://www.thesstech.com/pattern-matching-use-string-methods 

<!doctype html>
  <html>
    <head>
      <script>

        // 1st way

        var a = "apple";
        var b = "APPLE";  
        if (a.toUpperCase() === b.toUpperCase()) {
          alert("equal");
        }

        //2nd way

        var a = " Null and void";
        document.write(a.search(/null/i)); 

      </script>
    </head>
</html>
— सोहेल आरिफ
स्रोत
4

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

String.prototype.equalIgnoreCase = function(str)
{
    return (str != null 
            && typeof str === 'string'
            && this.toUpperCase() === str.toUpperCase());
}

इस तरह से आप इसे वैसे ही इस्तेमाल कर सकते हैं जैसे आप जावा में करते हैं!

उदाहरण:

var a = "hello";
var b = "HeLLo";
var c = "world";

if (a.equalIgnoreCase(b)) {
    document.write("a == b");
}
if (a.equalIgnoreCase(c)) {
    document.write("a == c");
}
if (!b.equalIgnoreCase(c)) {
    document.write("b != c");
}

आउटपुट होगा:

"a == b"
"b != c"

String.prototype.equalIgnoreCase = function(str) {
  return (str != null &&
    typeof str === 'string' &&
    this.toUpperCase() === str.toUpperCase());
}


var a = "hello";
var b = "HeLLo";
var c = "world";

if (a.equalIgnoreCase(b)) {
  document.write("a == b");
  document.write("<br>");
}
if (a.equalIgnoreCase(c)) {
  document.write("a == c");
}
if (!b.equalIgnoreCase(c)) {
  document.write("b != c");
}
स्निपेट का विस्तार करें

— Nebulosar
स्रोत
4

स्ट्रिंग मैच या तुलना के लिए RegEx का उपयोग करें।

जावास्क्रिप्ट में, आप match()स्ट्रिंग तुलना के लिए उपयोग कर सकते हैं , iRegEx में डालना मत भूलना ।

उदाहरण:

var matchString = "Test";
if (matchString.match(/test/i)) {
  alert('String matched');
}
else {
 alert('String not matched');
}
— ओम शर्मा
स्रोत
1
सुनिश्चित करें कि आप आंशिक मैचों के साथ ठीक हैं, अन्यथा matchString.match(/^test$/i)।
— हैकर
लोअरकेस "टेस्ट" के बजाय आपके पास var x = 'test' है, क्या matchString.match(/x/i)काम करेगा ? यदि नहीं, तो क्या काम करेगा?
— रज़वान ज़म्फिर
3

यदि दोनों तार एक ही ज्ञात स्थान के हैं, तो आप Intl.Collatorइस तरह से ऑब्जेक्ट का उपयोग करना चाह सकते हैं :

function equalIgnoreCase(s1: string, s2: string) {
    return new Intl.Collator("en-US", { sensitivity: "base" }).compare(s1, s2) === 0;
}

जाहिर है, आप Collatorबेहतर दक्षता के लिए कैश करना चाह सकते हैं ।

इस दृष्टिकोण का लाभ यह है कि यह RegExps का उपयोग करने की तुलना में बहुत तेज़ होना चाहिए और यह एक अत्यंत अनुकूलन योग्य है ( ऊपर आलेख में localesऔर optionsनिर्माण मापदंडों का विवरण देखें ) रेडी-टू- यूज़ कोलर्स के सेट पर।

— अलेक्जेंडर अबाकुमोव
स्रोत
संवेदनशीलता के लिए एक और विकल्प है accent, जो इसे असंवेदनशील रखता है, लेकिन व्यवहार करता है aऔर áअलग-अलग पात्रों के रूप में। तो baseया accentसटीक आवश्यकताओं के आधार पर दोनों उपयुक्त हो सकते हैं।
— मैथ्यू क्रूले
2

मैंने एक विस्तार लिखा। बहुत तुच्छ

if (typeof String.prototype.isEqual!= 'function') {
    String.prototype.isEqual = function (str){
        return this.toUpperCase()==str.toUpperCase();
     };
}
— झंकार महबूब
स्रोत
1
स्ट्रिंग # isEqual को एक ही समय में कैसे काम करने की कोशिश करनी चाहिए, इसके विभिन्न विचारों के साथ दो कोडबेस क्या होता है?
— रयान कैवानुआग
3
@KhanSharp बहुत से लोग इसे प्रकारों में निर्मित प्रोटोटाइप को संशोधित करने के लिए एक विरोधी पैटर्न मानते हैं। यही कारण है कि लोग आपके जवाब को वोट कर सकते हैं।
— jt000
1
क्या अज्ञात विधि परिभाषाओं को प्राथमिकता देना गलत नहीं है? उदाहरण के लिए जैसे ही कुछ ब्राउज़र को लागू करने का निर्णय लेते हैं String#isEqualया Object#isEqualमूल रूप से आपके सभी पृष्ठ अलग-अलग व्यवहार करते हैं और हो सकता है कि यदि विनिर्देश आपके बिल्कुल मेल नहीं खाते हैं तो वे अजीब चीजें कर सकते हैं।
— रॉबर्ट
2

यहां तक ​​कि इस सवाल का जवाब पहले ही दिया जा चुका है। मेरे पास RegExp का उपयोग करने और केस संवेदनशील को अनदेखा करने के लिए मैच करने के लिए एक अलग दृष्टिकोण है। कृपया मेरा लिंक https://jsfiddle.net/marchdave/7v8bd7dq/27/ देखें

$("#btnGuess").click(guessWord);

  function guessWord() {

   var letter = $("#guessLetter").val();
   var word = 'ABC';
   var pattern = RegExp(letter, 'gi'); // pattern: /a/gi

   var result = word.match(pattern);
   alert('Ignore case sensitive:' + result);

  }
— डेविड एस ली
स्रोत
1

कैसे के बारे में अपवाद नहीं फेंक रहे हैं और धीमी गति से उपयोग नहीं कर रहे हैं?

return str1 != null && str2 != null 
    && typeof str1 === 'string' && typeof str2 === 'string'
    && str1.toUpperCase() === str2.toUpperCase();

उपरोक्त स्निपेट मान लेता है कि आप मेल नहीं करना चाहते हैं यदि कोई स्ट्रिंग अशक्त या अपरिभाषित है।

यदि आप अशक्त / अपरिभाषित से मेल खाना चाहते हैं, तो:

return (str1 == null && str2 == null)
    || (str1 != null && str2 != null 
        && typeof str1 === 'string' && typeof str2 === 'string'
        && str1.toUpperCase() === str2.toUpperCase());

यदि किसी कारणवश आप अपरिभाषित बनाम अशक्त के बारे में परवाह करते हैं:

return (str1 === undefined && str2 === undefined)
    || (str1 === null && str2 === null)
    || (str1 != null && str2 != null 
        && typeof str1 === 'string' && typeof str2 === 'string'
        && str1.toUpperCase() === str2.toUpperCase());
— बेन वाइल्ड
स्रोत
या बसstr1 == str2 || ...
— SLaks
1

चूंकि कोई जवाब स्पष्ट रूप से उपयोग करने के लिए एक सरल कोड स्निपेट प्रदान नहीं किया गया है RegExp, यहां मेरा प्रयास है:

function compareInsensitive(str1, str2){ 
  return typeof str1 === 'string' && 
    typeof str2 === 'string' && 
    new RegExp("^" + str1.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&') + "$", "i").test(str2);
}

इसके कई फायदे हैं:

  1. पैरामीटर प्रकार (कोई भी गैर-स्ट्रिंग पैरामीटर, undefinedउदाहरण के लिए, अभिव्यक्ति की तरह क्रैश होगा str1.toUpperCase()) को सत्यापित करता है ।
  2. संभव अंतर्राष्ट्रीयकरण मुद्दों से ग्रस्त नहीं है।
  3. RegExpस्ट्रिंग से बच जाता है।
— ओहद श्नाइडर
स्रोत
लेकिन regexp की कमी से बच जाता है।
— 12
@ क्वर्टी फेयर पॉइंट, प्रति से बचकर जोड़ा गया stackoverflow.com/a/3561711/67824 ।
— ओहद श्नाइडर
0

यह इस उत्तर का एक उन्नत संस्करण है ।

String.equal = function (s1, s2, ignoreCase, useLocale) {
    if (s1 == null || s2 == null)
        return false;

    if (!ignoreCase) {
        if (s1.length !== s2.length)
            return false;

        return s1 === s2;
    }

    if (useLocale) {
        if (useLocale.length)
            return s1.toLocaleLowerCase(useLocale) === s2.toLocaleLowerCase(useLocale)
        else
            return s1.toLocaleLowerCase() === s2.toLocaleLowerCase()
    }
    else {
        if (s1.length !== s2.length)
            return false;

        return s1.toLowerCase() === s2.toLowerCase();
    }
}


Usages और परीक्षण:

कोड स्निपेट दिखाएं

— सेर्गेई
स्रोत
0

दोनों को लोअर में परिवर्तित करें (केवल एक बार प्रदर्शन कारणों से) और उनकी तुलना एक लाइन में टेनेरी ऑपरेटर से करें:

function strcasecmp(s1,s2){
    s1=(s1+'').toLowerCase();
    s2=(s2+'').toLowerCase();
    return s1>s2?1:(s1<s2?-1:0);
}
— लुका सी।
स्रोत
कौन कहता है C मरा है? : डी
— सेठ
0

यदि आप जानते हैं कि आप के साथ काम कर रहे हैं ascii पाठ के तो आप केवल एक अपरकेस / लोअरकेस वर्ण ऑफसेट तुलना का उपयोग कर सकते हैं।

बस यह सुनिश्चित कर लें कि स्ट्रिंग आपका "सही" स्ट्रिंग है (आप जिसके खिलाफ मैच करना चाहते हैं) लोअरकेस है:

const CHARS_IN_BETWEEN = 32;
const LAST_UPPERCASE_CHAR = 90; // Z
function strMatchesIgnoreCase(lowercaseMatch, value) {
    let i = 0, matches = lowercaseMatch.length === value.length;
    while (matches && i < lowercaseMatch.length) {
        const a = lowercaseMatch.charCodeAt(i);
        const A = a - CHARS_IN_BETWEEN;
        const b = value.charCodeAt(i);
        const B = b + ((b > LAST_UPPERCASE_CHAR) ? -CHARS_IN_BETWEEN : CHARS_IN_BETWEEN);
        matches = a === b // lowerA === b
            || A === b // upperA == b
            || a === B // lowerA == ~b
            || A === B; // upperA == ~b
        i++;
    }
    return matches;
}
— मात्स्को
स्रोत
0

मुझे यह त्वरित आशुलिपि भिन्नता पसंद है - 

export const equalsIgnoreCase = (str1, str2) => {
    return (!str1 && !str2) || (str1 && str2 && str1.toUpperCase() == str2.toUpperCase())
}

प्रसंस्करण में त्वरित, और वह करता है जो इसका इरादा है।

— नीतेश दादवरिया
स्रोत
0

यह javascript लाइब्रेरी बहुत सारे स्ट्रिंग ऑपरेशन प्रदान करती है। यह उपयोग करने के लिए बहुत सुविधाजनक है

स्थापित करने के लिए कैसे

npm install --save string

आयात

var S = require('string');

इग्नोरेसकेस की तुलना स्ट्रिंग से करें

var isEqual = S('ignoreCase').equalsIgnoreCase('IGNORECASE')
— आकाश
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.