Contiene distinzione tra maiuscole e minuscole

Ho il seguente:

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

Quello che mi piace fare è quello di rendere Ralmaiuscole e minuscole, in modo che possa essere RAl, rAle così via ed ancora corrispondere.

C'è un modo per dire che Raldeve fare distinzione tra maiuscole e minuscole?

Aggiungi .toLowerCase()dopo referrer. Questo metodo trasforma la stringa in una stringa in minuscolo. Quindi, utilizzare .indexOf()using ralanziché Ral.

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

Lo stesso può essere ottenuto anche usando un'espressione regolare (particolarmente utile quando si desidera testare modelli dinamici):

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

Un'altra opzione è utilizzare il metodo di ricerca come segue:

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

Sembra più elegante quindi convertire l'intera stringa in lettere minuscole e potrebbe essere più efficiente.
Con toLowerCase()il codice hanno due passaggi sopra la stringa, un passaggio è sull'intera stringa per convertirlo in lettere minuscole e un altro è cercare l'indice desiderato.
Con RegExpil codice hai un passaggio sulla stringa che sembra corrispondere all'indice desiderato.

Pertanto, su stringhe lunghe consiglio di utilizzare la RegExpversione (suppongo che su stringhe brevi questa efficienza sia dovuta alla creazione RegExpdell'oggetto)

Usa un RegExp:

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

Oppure usa .toLowerCase():

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

Da ES2016 puoi anche usare un metodo leggermente migliore / più semplice / più elegante (sensibile al maiuscolo / minuscolo):

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

o (senza distinzione tra maiuscole e minuscole):

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

Ecco alcuni paragoni di .indexOf()e .includes(): https://dev.to/adroitcoder/includes-vs-indexof-in-javascript

Ci sono un paio di approcci qui.

Se si desidera eseguire un controllo senza distinzione tra maiuscole e minuscole solo per questa istanza, eseguire una delle seguenti operazioni.

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

In alternativa, se si esegue regolarmente questo controllo, è possibile aggiungere un nuovo indexOf()metodo simile String, ma renderlo insensibile alle maiuscole.

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

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

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

Puoi provare questo

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

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

Esempio per qualsiasi lingua:

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

È il 2016 e non c'è modo chiaro di come farlo? Speravo in qualche copypasta. Ci proverò.

Note di progettazione: volevo ridurre al minimo l'utilizzo della memoria e quindi migliorare la velocità, quindi non è necessario copiare / mutare le stringhe. Presumo che V8 (e altri motori) possano ottimizzare questa funzione.

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

La mia ragione per il nome:

• Dovrebbe avere IndexOf nel nome
• Non aggiungere un suffisso - Of si riferisce al seguente parametro
• Non usare "caseInsensitive" che è talmente lungo
• "naturale" è un buon candidato, perché i confronti con distinzione tra maiuscole e minuscole non sono naturali per l'uomo in primo luogo.

Perchè no...:

• toLowerCase() - potenziali chiamate ripetute a toLowerCase sulla stessa stringa.
• RegExp- imbarazzante per cercare con variabile. Anche l'oggetto RegExp è imbarazzante dover scappare dai personaggi

Per fare una ricerca migliore usa il seguente codice,

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

Nel primo avviso (), JavaScript ha restituito "-1" - in altre parole, indexOf () non ha trovato una corrispondenza: questo semplicemente perché "JavaScript" è in minuscolo nella prima stringa e correttamente capitalizzato nella seconda. Per eseguire ricerche senza distinzione tra maiuscole e minuscole con indexOf (), è possibile rendere entrambe le stringhe maiuscole o minuscole. Ciò significa che, come nel secondo avviso (), JavaScript controlla solo la presenza della stringa che stai cercando, la maiuscola viene ignorata.

Riferimento, http://freewebdesigntutorials.com/javaScriptTutorials/jsStringObject/indexOfMethod.htm

Se referrerè un array, è possibile utilizzarefindIndex()

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

Ecco la mia opinione:

Script :

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