Como fazer comparação de strings sem distinção entre maiúsculas e minúsculas?

Como executo comparação de strings sem distinção entre maiúsculas e minúsculas em JavaScript?

A maneira mais simples de fazer isso (se você não estiver preocupado com caracteres Unicode especiais) é chamar toUpperCase:

var areEqual = string1.toUpperCase() === string2.toUpperCase();

EDIT : Esta resposta foi originalmente adicionada há 9 anos. Hoje você deve usar localeComparecom a sensitivity: 'accent'opção:

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

O { sensitivity: 'accent' }comando diz localeCompare()para tratar duas variantes da mesma letra base da mesma, a menos que tenham sotaques diferentes (como no terceiro exemplo) acima.

Como alternativa, você pode usar { sensitivity: 'base' }, que trata dois caracteres como equivalente, desde que o caractere base seja o mesmo (portanto, Aseria tratado como equivalente a á).

Observe que o terceiro parâmetro de localeComparenão é suportado no IE10 ou em navegadores móveis inferiores ou em certos dispositivos (consulte a tabela de compatibilidade na página acima), portanto, se você precisar oferecer suporte a esses navegadores, precisará de algum tipo de fallback:

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

Resposta original

A melhor maneira de fazer uma comparação sem distinção entre maiúsculas e minúsculas no JavaScript é usar o match()método RegExp com o isinalizador.

Pesquisa que não diferencia maiúsculas de minúsculas

Quando as duas strings comparadas são variáveis ​​(não constantes), é um pouco mais complicado, porque você precisa gerar um RegExp a partir da string, mas passar a string para o construtor RegExp pode resultar em correspondências incorretas ou falhas na correspondência, se a string possuir regex especial caracteres nele.

Se você se preocupa com a internacionalização, não use toLowerCase()ou toUpperCase()não forneça comparações precisas que não diferenciam maiúsculas de minúsculas em todos os idiomas.

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

Como dito em comentários recentes, string::localeComparesuporta comparações sem distinção entre maiúsculas e minúsculas (entre outras coisas poderosas).

Aqui está um exemplo simples

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

E uma função genérica que você poderia usar

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

Observe que, em vez de undefinedvocê provavelmente deve inserir o código do idioma específico com o qual está trabalhando. Isso é importante, conforme indicado nos documentos MDN

em sueco, ä e a são letras base separadas

Opções de sensibilidade

Suporte do navegador

No momento da postagem, o UC Browser para Android e Opera Mini não suporta parâmetros de localidade e opções . Verifique https://caniuse.com/#search=localeCompare para obter informações atualizadas.

Com a ajuda da expressão regular também podemos alcançar.

(/keyword/i).test(source)

/ié para ignorar maiúsculas e minúsculas. Se não for necessário, podemos ignorar e testar a correspondência NÃO sensível a maiúsculas e minúsculas, como

(/keyword/).test(source)

Lembre-se de que a caixa é uma operação específica do código do idioma. Dependendo do cenário, convém levar isso em consideração. Por exemplo, se você estiver comparando nomes de duas pessoas, considere o código de idioma, mas se estiver comparando valores gerados por máquina, como UUID, talvez não. É por isso que uso a seguinte função na minha biblioteca de utilitários (observe que a verificação de tipo não está incluída por motivos de desempenho).

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

Recentemente, criei uma micro biblioteca que fornece auxiliares de string que não diferenciam maiúsculas de minúsculas: https://github.com/nickuraltsev/ignore-case . (Ele usa toUpperCaseinternamente.)

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

se você está preocupado com a direção da desigualdade (talvez queira classificar uma lista), é necessário fazer a conversão de maiúsculas e minúsculas e, como existem mais caracteres minúsculos em unicode do que maiúsculas em LowerCase, provavelmente é a melhor conversão a ser usada.

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

O Javascript parece usar o código de idioma "C" para comparações de strings, portanto a ordem resultante será feia se as strings contiverem letras que não sejam ASCII. não há muito que possa ser feito sobre isso sem fazer uma inspeção muito mais detalhada das strings.

Suponha que desejamos encontrar a variável string needlena variável string haystack. Existem três dicas:

1. Aplicativos internacionalizados devem evitar string.toUpperCasee string.toLowerCase. Use uma expressão regular que ignore maiúsculas e minúsculas. Por exemplo, var needleRegExp = new RegExp(needle, "i");seguido por needleRegExp.test(haystack).
2. Em geral, você pode não saber o valor de needle. Cuidado para needlenão conter caracteres especiais de expressão regular . Fuja deles usando needle.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");.
3. Em outros casos, se você deseja corresponder com precisão needlee haystack, apenas ignorando o caso, adicione "^"-o no início e "$"no final do construtor de expressões regulares.

Levando em consideração os pontos (1) e (2), um exemplo seria:

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
}

Existem duas maneiras de comparação sem distinção entre maiúsculas e minúsculas:

1. Converta seqüências de caracteres em maiúsculas e compare-as usando o operador strict ( ===). Como o operador rigoroso trata os operandos lê o material em: http://www.thesstech.com/javascript/relational-logical-operators
2. Correspondência de padrões usando métodos de string:

Use o método de string "search" para pesquisa que não diferencia maiúsculas de minúsculas. Leia sobre a pesquisa e outros métodos de string em: http://www.thesstech.com/pattern-matching-using-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>

Muitas respostas aqui, mas eu gostaria de adicionar uma solução baseada na extensão da biblioteca String:

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

Dessa forma, você pode usá-lo como em Java!

Exemplo:

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 saída será:

"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");
}

Use RegEx para correspondência ou comparação de cadeias de caracteres.

Em JavaScript, você pode usar match()para comparação de cadeias, não se esqueça de colocar ino RegEx.

Exemplo:

var matchString = "Test";
if (matchString.match(/test/i)) {
  alert('String matched');
}
else {
 alert('String not matched');
}

str = 'Lol', str2 = 'lOl', regex = new RegExp('^' + str + '$', 'i');
if (regex.test(str)) {
    console.log("true");
}

Se ambas as seqüências de caracteres tiverem o mesmo código de idioma conhecido, convém usar Intl.Collatorobjetos como este:

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

Obviamente, convém armazenar em cache o Collatorpara obter melhor eficiência.

As vantagens dessa abordagem é que ela deve ser muito mais rápida do que usar o RegExps e se baseia em um conjunto extremamente personalizável (veja descrição localese optionsparâmetros do construtor no artigo acima) de separadores prontos para uso.

Eu escrevi uma extensão. muito trivial

if (typeof String.prototype.isEqual!= 'function') {
    String.prototype.isEqual = function (str){
        return this.toUpperCase()==str.toUpperCase();
     };
}

Até esta pergunta já respondeu. Eu tenho uma abordagem diferente para usar RegExp e corresponder para ignorar maiúsculas de minúsculas. Por favor, veja o meu link 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);

  }

Que tal NÃO lançar exceções e NÃO usar regex lento?

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

O snippet acima pressupõe que você não deseja corresponder se uma sequência for nula ou indefinida.

Se você deseja corresponder nulo / indefinido, então:

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

Se, por algum motivo, você se importar com undefined vs null:

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

Como nenhuma resposta forneceu claramente um trecho de código simples para uso RegExp, eis a minha tentativa:

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

Tem várias vantagens:

1. Verifica o tipo de parâmetro (qualquer parâmetro que não seja de seqüência de caracteres, como undefinedpor exemplo, trava uma expressão como str1.toUpperCase()).
2. Não sofre de possíveis problemas de internacionalização.
3. Escapa a RegExpstring.

Esta é uma versão melhorada de esta resposta .

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

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

// If you don't mind extending the prototype.
String.prototype.equal = function(string2, ignoreCase, useLocale) {
  return String.equal(this.valueOf(), string2, ignoreCase, useLocale);
}

// ------------------ TESTS ----------------------
console.log("Tests...");

console.log('Case sensitive 1');
var result = "Abc123".equal("Abc123");
console.assert(result === true);

console.log('Case sensitive 2');
result = "aBC123".equal("Abc123");
console.assert(result === false);

console.log('Ignore case');
result = "AbC123".equal("aBc123", true);
console.assert(result === true);

console.log('Ignore case + Current locale');
result = "AbC123".equal("aBc123", true);
console.assert(result === true);

console.log('Turkish test 1 (ignore case, en-US)');
result = "IiiI".equal("ıiİI", true, "en-US");
console.assert(result === false);

console.log('Turkish test 2 (ignore case, tr-TR)');
result = "IiiI".equal("ıiİI", true, "tr-TR");
console.assert(result === true);

console.log('Turkish test 3 (case sensitive, tr-TR)');
result = "IiiI".equal("ıiİI", false, "tr-TR");
console.assert(result === false);

console.log('null-test-1');
result = "AAA".equal(null);
console.assert(result === false);

console.log('null-test-2');
result = String.equal(null, "BBB");
console.assert(result === false);

console.log('null-test-3');
result = String.equal(null, null);
console.assert(result === false);

Converta ambos em menor (apenas uma vez por motivos de desempenho) e compare-os com o operador ternário em uma única linha:

function strcasecmp(s1,s2){
    s1=(s1+'').toLowerCase();
    s2=(s2+'').toLowerCase();
    return s1>s2?1:(s1<s2?-1:0);
}

Se você sabe que está lidando com asciitexto, basta usar uma comparação de deslocamento de caracteres em maiúsculas / minúsculas.

Apenas certifique-se de que a string "perfeita" (a que você deseja corresponder) esteja em minúscula:

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

Eu gosto dessa variação rápida de taquigrafia -

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

Rápido no processamento e faz o que se destina.

Essa javascript biblioteca parece fornecer muitas operações de string. É muito conveniente usar

Como instalar

npm install --save string

Importar

var S = require('string');

String de Ignorecase Compare

var isEqual = S('ignoreCase').equalsIgnoreCase('IGNORECASE')