मामला असंवेदनशील है

413

मेरे पास निम्नलिखित हैं:

if (referrer.indexOf("Ral") == -1) { ... }

मुझे क्या करना चाहते बनाने के लिए है Ralयह हो सकता है इतना है कि केस संवेदी, RAl, rAl, आदि और अभी भी मेल खाते हैं।

क्या यह कहने का कोई तरीका है कि Ralमामला असंवेदनशील होना चाहिए?

— नैट पेट
स्रोत

3

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

— १२:१४ को

604

के .toLowerCase()बाद जोड़ें referrer। यह विधि स्ट्रिंग को कम केस स्ट्रिंग में बदल देती है। फिर, के बजाय का उपयोग .indexOf()कर का उपयोग करें ।ralRal

if (referrer.toLowerCase().indexOf("ral") === -1) {

एक नियमित अभिव्यक्ति (विशेष रूप से उपयोगी जब आप गतिशील पैटर्न के खिलाफ परीक्षण करना चाहते हैं) का उपयोग करके भी इसे प्राप्त किया जा सकता है:

if (!/Ral/i.test(referrer)) {
   //    ^i = Ignore case flag for RegExp

— रॉब डब्ल्यू
स्रोत

16

उत्तरार्द्ध विधि अधिक सही है; पूर्व तुर्की I और इस तरह के किसी भी अन्य समस्याग्रस्त अपरकेस / लोअरकेस जोड़े के लिए विफल रहेगा: i18nguy.com/unicode/tiki-i18n.html

— डोमिनिक

23

तुर्की के लिए, यह toLocaleLowerCase()( रेफरी ) का उपयोग करना बेहतर होगा

— मॉटी

2

उत्तरार्द्ध प्रश्न का उत्तर नहीं देता है, यह केवल यह कहता है कि यदि यह वहां है, तो मैच का सूचकांक प्राप्त न करें। या तो प्रश्न शीर्षक गलत है, या प्रश्न।

— मास्लो

10

@ मैस्लो प्रश्न का उदाहरण परीक्षण मामले की असंवेदनशीलता के बारे में था। यदि आप सूचकांक प्राप्त करना चाहते हैं, तो स्ट्रिंग की.search विधि का उपयोग करें:var index = referrer.search(/Ral/i);

— रोब डब्ल्यू

7

डायनेमिक रेगुलर एक्सप्रेशन अप्रोच की अतिरिक्त जटिलता यह है कि यदि खोज स्ट्रिंग, जैसे "आरएएल", में रेग्युलर एक्सप्रेशन विशेष वर्ण, जैसे $ * शामिल हैं? आदि, आपको समस्याएं होंगी, इसलिए आपको विशेष पात्रों से बचने की आवश्यकता होगी, इस पोस्ट पर माइक सैमुअल का उत्तर देखें: अंत में जावास्क्रिप्ट में

— zachelrath

94

एक अन्य विकल्प खोज विधि का उपयोग इस प्रकार है:

if (referrer.search(new RegExp("Ral", "i")) == -1) { ...

यह अधिक सुरुचिपूर्ण दिखता है और पूरे स्ट्रिंग को निचले मामले में परिवर्तित करता है और यह अधिक कुशल हो सकता है।
साथ toLowerCase()कोड है स्ट्रिंग पर दो पास, एक पास पूरी स्ट्रिंग पर है लोअर केस में यह परिवर्तित करने के लिए और एक अन्य वांछित सूचकांक देखने के लिए है। कोड के
साथ RegExpस्ट्रिंग के ऊपर एक पास होता है जो वांछित सूचकांक से मेल खाता है।

इसलिए, लंबे स्ट्रिंग्स पर मैं RegExpसंस्करण का उपयोग करने की सलाह देता हूं (मुझे लगता है कि शॉर्ट स्ट्रिंग्स पर यह दक्षता RegExpऑब्जेक्ट बनाने के कारण आती है )

— केफिर इरेज़
स्रोत

2

यह भी मेरे परीक्षणों के आधार पर काफी तेज है: jsperf.com/case-insensitive-indexof

— इलान बिआला

6

2018.10.24 तक, क्रोम में एक बड़े अंतर से टावेलकेस जीतता है। toLowerCase (95,914,378 -% 0.89% - सबसे तेज़), regex indexOf (269,307 - 87 0.87% 100% धीमा)

— nixkuroi

21

एक RegExp का उपयोग करें:

if (!/ral/i.test(referrer)) {
    ...
}

या, उपयोग करें .toLowerCase():

if (referrer.toLowerCase().indexOf("ral") == -1)

— gilly3
स्रोत

1

+1, यह संभावित रूप से "तुर्की I समस्या" और इस तरह के अन्य नुकसानों से बचकर अधिक सही हो सकता है: i18nguy.com/unicode/tiki-i18n.html

— डोमिनिक

15

ES2016 से आप थोड़ा बेहतर / आसान / अधिक सुरुचिपूर्ण विधि (केस-संवेदी) का उपयोग कर सकते हैं:

if (referrer.includes("Ral")) { ... }

या (केस-असंवेदनशील):

if (referrer.toLowerCase().includes(someString.toLowerCase())) { ... }

यहाँ कुछ तुलना की गई है .indexOf()और .includes(): https://dev.to/adroitcoder/includes-vs-indexof-in-wasascript

— Łुकाज़ माटज़्यूस्की
स्रोत

1

मुझे नहीं लगता कि इसमें शामिल मामला असंवेदनशील है

— काइल का

4

@Kyles includesहै केस-संवेदी में क्रोम: कोशिश 'fooBar'.includes('bar')==>false

— drzaus

10

यहाँ कुछ दृष्टिकोण हैं।

यदि आप इस उदाहरण के लिए केस-असंवेदनशील जांच करना चाहते हैं, तो निम्न जैसा कुछ करें।

if (referrer.toLowerCase().indexOf("Ral".toLowerCase()) == -1) {
    ...

वैकल्पिक रूप से, यदि आप इस चेक को नियमित रूप से कर रहे हैं, तो आप इसमें एक नई indexOf()तरह की विधि जोड़ सकते हैं String, लेकिन इसे असंवेदनशील बना सकते हैं।

String.prototype.indexOfInsensitive = function (s, b) {
    return this.toLowerCase().indexOf(s.toLowerCase(), b);
}

// Then invoke it
if (referrer.indexOfInsensitive("Ral") == -1) { ...

— cheeken
स्रोत

1

आधुनिक ब्राउज़रों के लिए जो समर्थन करते हैं defineProperty, मैं सुझाव देता हूं

Object.defineProperty(String.prototype, 'indexOfInsensitive', {value: function(s,b){return this.toLowerCase().indexOf((s+'').toLowerCase(),b);}});

। दो अपडेट: स्पष्ट स्ट्रिंग रूपांतरण का उपयोग करना (s+''), और एक लूप में गैर-एन्यूमरेबल ( for(var i in '') ... नहीं दिखाता है indexOfInsensitive।

— रोब डब्ल्यू

5

if (referrer.toUpperCase().indexOf("RAL") == -1) { ...

— केंडल फ्रे
स्रोत

@ डॉमिक: तुर्की संस्कृति के सभी सम्मान के साथ, तुर्की को इस पहलू को सरल बनाने के लिए वर्तनी सुधार पर विचार करना चाहिए । चीन में कई सरलीकरण सुधार हुए हैं , और तुर्की में 10% से कम चीन की आबादी है, और बहुत सरल वर्णमाला है। यह किया जा सकता है।

— डैन डस्केल्सस्कु

5

आप यह कोशिश कर सकते हैं

str = "Wow its so COOL"
searchStr = "CoOl"

console.log(str.toLowerCase().includes(searchStr.toLowerCase()))

स्निपेट का विस्तार करें

— बकराली सुनसरा
स्रोत

3

किसी भी भाषा के लिए उदाहरण:

'My name is Хведор'.toLocaleLowerCase().includes('ХвЕдОр'.toLocaleLowerCase())

— alex_1948511
स्रोत

2

यह 2016 है, और ऐसा करने का कोई स्पष्ट तरीका नहीं है? मैं कुछ कोपिपास्ता की उम्मीद कर रहा था। मुझे जाना होगा।

डिज़ाइन नोट्स: मैं स्मृति उपयोग को कम करना चाहता था, और इसलिए गति में सुधार - इसलिए स्ट्रिंग्स की कोई नकल / उत्परिवर्तन नहीं है। मुझे लगता है कि V8 (और अन्य इंजन) इस फ़ंक्शन को अनुकूलित कर सकते हैं।

//TODO: Performance testing
String.prototype.naturalIndexOf = function(needle) {
    //TODO: guard conditions here

    var haystack = this; //You can replace `haystack` for `this` below but I wan't to make the algorithm more readable for the answer
    var needleIndex = 0;
    var foundAt = 0;
    for (var haystackIndex = 0; haystackIndex < haystack.length; haystackIndex++) {
        var needleCode = needle.charCodeAt(needleIndex);
        if (needleCode >= 65 && needleCode <= 90) needleCode += 32; //ToLower. I could have made this a function, but hopefully inline is faster and terser
        var haystackCode = haystack.charCodeAt(haystackIndex);
        if (haystackCode >= 65 && haystackCode <= 90) haystackCode += 32; //ToLower. I could have made this a function, but hopefully inline is faster and terser

        //TODO: code to detect unicode characters and fallback to toLowerCase - when > 128?
        //if (needleCode > 128 || haystackCode > 128) return haystack.toLocaleLowerCase().indexOf(needle.toLocaleLowerCase();
        if (haystackCode !== needleCode)
        {
            foundAt = haystackIndex;
            needleIndex = 0; //Start again
        }
        else
            needleIndex++;

        if (needleIndex == needle.length)
            return foundAt;
    }

    return -1;
}

मेरे नाम का कारण:

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

क्यों नहीं...:

toLowerCase() - एक ही स्ट्रिंग पर संभावित बार-बार कॉल toLowerCase।
RegExp- चर के साथ खोज करने के लिए अजीब। यहां तक कि RegExp ऑब्जेक्ट पात्रों से बचने के लिए अजीब है

— टोड
स्रोत

2

यह 2016 है, और आप अभी भी सोचते हैं कि अंग्रेजी (या अन्य एएससीआईआई-केवल भाषाएँ) दुनिया में एकमात्र भाषा है?

— रोलैंड इलिग

3

@ रोलैंडिग ऑच। मेरा उत्तर अन्य संस्कृतियों को समायोजित नहीं करता है, यह एक खामी है। मैं अधिक संस्कृतियों के लिए व्यापक समर्थन में किसी भी अंतर्दृष्टि का स्वागत करता हूं, दुनिया सहयोगियों के साथ एक बेहतर स्थान है।

— टोड

1

एक बेहतर खोज करने के लिए निम्नलिखित कोड का उपयोग करें,

var myFav   = "javascript";
var theList = "VB.NET, C#, PHP, Python, JavaScript, and Ruby";

// Check for matches with the plain vanilla indexOf() method:
alert( theList.indexOf( myFav ) );

// Now check for matches in lower-cased strings:
alert( theList.toLowerCase().indexOf( myFav.toLowerCase() ) );

पहले अलर्ट में (), जावास्क्रिप्ट ने "-1" लौटाया - दूसरे शब्दों में, indexOf () को एक मैच नहीं मिला: यह केवल इसलिए है क्योंकि "जावास्क्रिप्ट" पहले स्ट्रिंग में लोअरकेस में है, और दूसरे में ठीक से कैपिटल है। IndexOf () के साथ केस-असंवेदनशील खोजों को करने के लिए, आप दोनों स्ट्रिंग को अपरकेस या लोअरकेस बना सकते हैं। इसका मतलब है कि, दूसरे अलर्ट () के रूप में, जावास्क्रिप्ट केवल उस स्ट्रिंग की घटना की जांच करेगा जिसे आप खोज रहे हैं, पूंजीकरण की अनदेखी की गई है।

संदर्भ, http://freewebdesigntutorials.com/javaScriptTutorials/jsStringObject/indexOfMethod.htm

— दिगंत कुमार
स्रोत

1

यदि referrerएक सरणी है, तो आप उपयोग कर सकते हैंfindIndex()

 if(referrer.findIndex(item => 'ral' === item.toLowerCase()) == -1) {...}

— ए-Sharabiani
स्रोत

0

यहाँ मेरा ले रहा है:

स्क्रिप्ट :

var originalText = $("#textContainer").html()
$("#search").on('keyup', function () {
  $("#textContainer").html(originalText)
  var text = $("#textContainer").html()
  var val = $("#search").val()
  if(val=="") return;
  var matches = text.split(val)
  for(var i=0;i<matches.length-1;i++) {
    var ind =  matches[i].indexOf(val)
    var len = val.length
      matches[i] = matches[i] + "<span class='selected'>" + val + "</span>"
  }
  $("#textContainer").html(matches.join(""))

HTML:

<input type="text" id="search">
<div id="textContainer">
lorem ipsum is simply dummy text of the printing and typesetting industry. lorem ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of letraset sheets containing lorem ipsum passages, and more recently with desktop publishing software like Aldus pagemaker including versions of lorem ipsum.</div>

Codepen

— माइकल सेल्टेनरिच
स्रोत