Contém maiúsculas e minúsculas


413

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?


3
Acho que o regex que não diferencia maiúsculas de minúsculas é a solução mais elegante, mas todos devem ter em mente as armadilhas da criação de uma RegExpentrada diretamente do usuário. Por exemplo, um usuário pode entrar *e um erro será gerado no RegExpconstrutor. A solução aceita não tem esse problema.
pllee

Respostas:


604

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

16
O último método é mais correto; o ex-falhará para o turco I e quaisquer outras maiúsculas problemático / pares de minúsculas: i18nguy.com/unicode/turkish-i18n.html
Domenic

23
Para Turco, seria melhor usar toLocaleLowerCase()( ref )
Mottie

2
o último não responde à pergunta, apenas diz se está lá, não obtém o índice da partida. O título da pergunta está errado ou a pergunta.
Maslow

10
@ Maslow O exemplo da pergunta foi sobre insensibilidade de caso de teste. Se você deseja obter o índice, use o método String.search :var index = referrer.search(/Ral/i);
Rob W

7
A complicação adicional da abordagem da Expressão regular dinâmica é que, se a sequência de pesquisa, por exemplo, "Ral", contiver caracteres especiais da Expressão regular, como $. *? etc., você teria problemas, portanto, precisaria escapar dos caracteres especiais. Consulte a resposta de Mike Samuel nesta postagem: termina com JavaScript
zachelrath

94

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)


2
Este também é um pouco mais rápido com base em meus testes: jsperf.com/case-insensitive-indexof
Ilan Biala

6
A partir de 24/10/2018, o toLowerCase vence por uma grande margem no Chrome. toLowerCase (95914378 - ± 0,89% - mais rápido), regex indexOf (269.307 - ± 0,87% 100% mais lenta)
nixkuroi


15

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


1
Eu não acho que inclui é caso insensível
Kyle s

4
O @Kyles includesfaz distinção entre maiúsculas e minúsculas no Chrome: try 'fooBar'.includes('bar')==>false
drzaus

10

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

1
Para navegadores modernos compatíveis defineProperty, eu sugiro Object.defineProperty(String.prototype, 'indexOfInsensitive', {value: function(s,b){return this.toLowerCase().indexOf((s+'').toLowerCase(),b);}});. Duas atualizações: Conversão explícita de cadeias usando (s+'')e não enumerável em um loop ( for(var i in '') ... não aparece indexOfInsensitive.
Rob W

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

@Domenic: Com todo o devido respeito à cultura turca, a Turquia deve considerar uma reforma ortográfica para simplificar esse aspecto. A China teve várias reformas de simplificação , e a Turquia tem menos de 10% da população da China e um alfabeto muito mais simples. Pode ser feito.
Dan Dascalescu

5

Você pode tentar isso

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

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


3

Exemplo para qualquer idioma:

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

2

É 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

2
É 2016 e você ainda acha que o inglês (ou outros idiomas somente ASCII) é o único idioma do mundo?
Roland Illig 09/04

3
@RolandIllig Ouch. Minha resposta não acomoda outras culturas, isso é uma desvantagem. Gostaria de receber qualquer insight sobre a ampliação do suporte a mais culturas, o mundo é um lugar melhor para os colaboradores.
Todd

1

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


1

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

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

0

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

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.