Contém maiúsculas e minúsculas

Eu tenho o seguinte:

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

O que eu gostaria de fazer é fazer com que Ralmaiúsculas e minúsculas, de modo que ele pode ser RAl, rAl, etc. e ainda igualar.

Existe uma maneira de dizer que isso Ralnão diferencia maiúsculas de minúsculas?

Adicione .toLowerCase()depois referrer. Esse método transforma a string em uma minúscula. Em seguida, use .indexOf()usando em ralvez de Ral.

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

O mesmo também pode ser alcançado usando uma expressão regular (especialmente útil quando você deseja testar padrões dinâmicos):

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

Outra opção é usar o método de pesquisa da seguinte maneira:

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

Parece mais elegante do que converter toda a cadeia para minúscula e pode ser mais eficiente.
Com toLowerCase()o código tem duas passagens sobre a sequência, uma passagem está na sequência inteira para convertê-la em minúsculas e outra é procurar o índice desejado.
Com RegExpo código, passe uma sobre a string que parece corresponder ao índice desejado.

Portanto, em cordas longas, recomendo usar a RegExpversão (acho que em cordas curtas essa eficiência é responsável pela criação do RegExpobjeto)

Use um RegExp:

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

Ou use .toLowerCase():

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

No ES2016, você também pode usar o método um pouco melhor / mais fácil / mais elegante (diferencia maiúsculas de minúsculas):

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

ou (sem distinção entre maiúsculas e minúsculas):

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

Aqui está uma comparação de .indexOf()e .includes(): https://dev.to/adroitcoder/includes-vs-indexof-in-javascript

Existem algumas abordagens aqui.

Se você deseja executar uma verificação sem distinção entre maiúsculas e minúsculas apenas para esta instância, faça algo como o seguinte.

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

Como alternativa, se você estiver executando essa verificação regularmente, poderá adicionar um novo indexOf()método semelhante a String, mas torná-lo sem distinção entre maiúsculas e minúsculas.

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) { ...

Você pode tentar isso

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

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

Exemplo para qualquer idioma:

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

É 2016 e não há uma maneira clara de como fazer isso? Eu estava esperando um pouco de copypasta. Eu vou tentar.

Notas de design: eu queria minimizar o uso de memória e, portanto, melhorar a velocidade - para que não haja cópia / mutação de strings. Presumo que o V8 (e outros mecanismos) possa otimizar essa função.

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

Minha razão para o nome:

• Deve ter IndexOf no nome
• Não adicione um sufixo - Of refere-se ao seguinte parâmetro
• Não use "caseInsensitive", que é muuuito longo
• "natural" é um bom candidato, porque as comparações sensíveis a maiúsculas e minúsculas não são naturais para os seres humanos em primeiro lugar.

Por que não...:

• toLowerCase() - possíveis chamadas repetidas para toLowerCase na mesma sequência.
• RegExp- estranho procurar com variável. Até o objeto RegExp é estranho, tendo que escapar caracteres

Para fazer uma pesquisa melhor, use o código a seguir,

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

No primeiro alerta (), o JavaScript retornou "-1" - em outras palavras, indexOf () não encontrou uma correspondência: isso ocorre simplesmente porque "JavaScript" está em minúscula na primeira string e em maiúscula na segunda. Para executar pesquisas que não diferenciam maiúsculas de minúsculas com indexOf (), você pode criar ambas as strings em maiúsculas ou minúsculas. Isso significa que, como no segundo alerta (), o JavaScript verificará apenas a ocorrência da sequência que você está procurando, com letras maiúsculas ignoradas.

Referência, http://freewebdesigntutorials.com/javaScriptTutorials/jsStringObject/indexOfMethod.htm

Se referreré uma matriz, você pode usarfindIndex()

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

Aqui está a minha opinião:

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