¿Cómo hacer una comparación de cadenas insensible a mayúsculas y minúsculas?

¿Cómo realizo la comparación de cadenas sin distinción entre mayúsculas y minúsculas en JavaScript?

La forma más sencilla de hacerlo (si no le preocupan los caracteres Unicode especiales) es llamar toUpperCase:

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

EDITAR : Esta respuesta se agregó originalmente hace 9 años. Hoy deberías usar localeComparecon la sensitivity: 'accent'opción:

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

El { sensitivity: 'accent' }le dice localeCompare()que trate dos variantes de la misma letra base como la misma, a menos que tengan acentos diferentes (como en el tercer ejemplo) anterior.

Alternativamente, puede usar { sensitivity: 'base' }, que trata dos caracteres como equivalentes siempre que su carácter base sea el mismo (por Alo que se trataría como equivalente a á).

Tenga en cuenta que el tercer parámetro de localeCompareno es compatible con IE10 o navegadores móviles inferiores o determinados (consulte la tabla de compatibilidad en la página vinculada anteriormente), por lo que si necesita admitir esos navegadores, necesitará algún tipo de respaldo:

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

Respuesta original

La mejor manera de hacer una comparación entre mayúsculas y minúsculas en JavaScript es usar el match()método RegExp con la ibandera.

Búsqueda sin distinción entre mayúsculas y minúsculas

Cuando ambas cadenas que se comparan son variables (no constantes), entonces es un poco más complicado porque necesita generar un RegExp a partir de la cadena, pero pasar la cadena al constructor RegExp puede resultar en coincidencias incorrectas o fallas si la cadena tiene expresiones regulares especiales personajes en el mismo.

Si le importa la internacionalización, no la use toLowerCase()o toUpperCase()no proporciona comparaciones precisas que no distingan entre mayúsculas y minúsculas en todos los idiomas.

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

Como se dijo en comentarios recientes, string::localeCompareadmite comparaciones que no distinguen entre mayúsculas y minúsculas (entre otras cosas poderosas).

Aquí hay un ejemplo simple

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

Y una función genérica que podrías usar

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

Tenga en cuenta que en lugar de undefinedusted probablemente debería ingresar la configuración regional específica con la que está trabajando. Esto es importante como se indica en los documentos de MDN

en sueco, ä y a son letras base separadas

Opciones de sensibilidad

Soporte del navegador

Al momento de la publicación, UC Browser para Android y Opera Mini no admiten parámetros de configuración regional y opciones . Consulte https://caniuse.com/#search=localeCompare para obtener información actualizada.

Con la ayuda de la expresión regular también podemos lograr.

(/keyword/i).test(source)

/ies por ignorar caso. Si no es necesario, podemos ignorar y probar NO coincide con mayúsculas y minúsculas como

(/keyword/).test(source)

Recuerde que la carcasa es una operación específica de la localidad. Dependiendo del escenario, es posible que desee tener eso en cuenta. Por ejemplo, si está comparando los nombres de dos personas, es posible que desee considerar la configuración regional, pero si está comparando valores generados por la máquina, como UUID, es posible que no lo haga. Es por eso que uso la siguiente función en mi biblioteca de utilidades (tenga en cuenta que la verificación de tipos no está incluida por razones de rendimiento).

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

Recientemente he creado una micro biblioteca que proporciona ayudantes de cadena que no distinguen entre mayúsculas y minúsculas: https://github.com/nickuraltsev/ignore-case . (Se 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

si le preocupa la dirección de la desigualdad (tal vez desee ordenar una lista), prácticamente tiene que hacer una conversión de mayúsculas y minúsculas, ya que hay más caracteres en minúscula en unicode que mayúsculas a LowCase es probablemente la mejor conversión para usar.

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

Javascript parece usar la configuración regional "C" para las comparaciones de cadenas, por lo que el orden resultante será feo si las cadenas contienen letras distintas de ASCII. no se puede hacer mucho al respecto sin hacer una inspección mucho más detallada de las cadenas.

Supongamos que queremos encontrar la variable de cadena needleen la variable de cadena haystack. Hay tres trampas:

1. Las aplicaciones internacionalizadas deben evitarse string.toUpperCasey string.toLowerCase. Utilice una expresión regular que ignore mayúsculas y minúsculas. Por ejemplo, var needleRegExp = new RegExp(needle, "i");seguido de needleRegExp.test(haystack).
2. En general, es posible que no conozca el valor de needle. Tenga cuidado de que needleno contenga ninguna expresión especial de caracteres especiales . Escapar de estos utilizandoneedle.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"); .
3. En otros casos, si desea hacer coincidir con precisión needley haystack, simplemente ignorando mayúsculas y minúsculas, asegúrese de agregar "^"al comienzo y "$"al final de su constructor de expresiones regulares.

Teniendo en cuenta los puntos (1) y (2), un ejemplo sería:

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
}

Hay dos formas de comparación entre mayúsculas y minúsculas:

1. Convierta cadenas a mayúsculas y luego compárelas usando el operador estricto ( ===). Cómo el operador estricto trata los operandos lee cosas en: http://www.thesstech.com/javascript/relational-logical-operators
2. Coincidencia de patrones utilizando métodos de cadena:

Utilice el método de cadena "buscar" para la búsqueda sin distinción entre mayúsculas y minúsculas. Lea sobre la búsqueda y otros métodos de cadena en: 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>

Muchas respuestas aquí, pero me gusta agregar una solución basada en extender la lib de String:

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

¡De esta manera puedes usarlo como lo haces en Java!

Ejemplo:

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

La salida 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 la coincidencia de cadenas o la comparación.

En JavaScript, puede usar match()para la comparación de cadenas, no olvide poneri RegEx.

Ejemplo:

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

Si ambas cadenas son de la misma configuración regional conocida, es posible que desee utilizar un Intl.Collatorobjeto como este:

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

Obviamente, es posible que desee almacenar en caché Collatorpara una mejor eficiencia.

Las ventajas de este enfoque es que debería ser mucho más rápido que usar RegExps y se basa en un conjunto extremadamente personalizable (consulte la descripción localesy optionslos parámetros del constructor en el artículo anterior) de los collares listos para usar.

Escribí una extensión. muy trivial

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

Incluso esta pregunta ya ha respondido. Tengo un enfoque diferente para usar RegExp y coincidir para ignorar mayúsculas y minúsculas. Por favor vea mi enlace 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);

  }

¿Qué tal NO lanzar excepciones y NO usar expresiones regulares lentas?

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

El fragmento anterior supone que no desea hacer coincidir si cualquiera de las cadenas es nula o no está definida.

Si desea hacer coincidir nulo / indefinido, entonces:

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

Si por alguna razón te importa indefinido vs nulo:

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

Como ninguna respuesta proporcionó claramente un fragmento de código simple para usar RegExp, este es mi intento:

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

Tiene varias ventajas:

1. Verifica el tipo de parámetro (cualquier parámetro que no sea de cadena, como undefinedpor ejemplo, bloquearía una expresión como str1.toUpperCase()).
2. No sufre de posibles problemas de internacionalización.
3. Se escapa de la RegExpcuerda.

Esta es una versión mejorada de esta respuesta .

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

Convierta ambos a menor (solo una vez por razones de rendimiento) y compárelos con el operador ternario en una sola línea:

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

Si sabe que está tratando con asciitexto, puede usar una comparación de desplazamiento de caracteres en mayúsculas / minúsculas.

Solo asegúrese de que la cadena de su cadena "perfecta" (con la que desea hacer coincidir) esté en minúsculas:

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

Me gusta esta variación rápida de taquigrafía:

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

Procesamiento rápido y hace lo que se pretende.

Esta javascript biblioteca parece proporcionar muchas operaciones de cadena. Es muy conveniente de usar

Cómo instalar

npm install --save string

Importar

var S = require('string');

Ignorecase Compare String

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