РЕДАКТИРОВАТЬ: Этот ответ был первоначально добавлен 9 лет назад. Сегодня вы должны использоватьlocaleCompare сsensitivity: 'accent' опция:

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

{ sensitivity: 'accent' } говоритlocaleCompare() рассматривать два варианта одной и той же базовой буквы как одинаковыеесли у них разные акценты (как в третьем примере) выше.

Кроме того, вы можете использовать{ sensitivity: 'base' }, который обрабатывает два символа как эквивалентные, если их базовый символ одинаков (такA будет рассматриваться как эквивалентá).

Заметка что третий параметрlocaleCompare не поддерживается в IE10 или более ранних версиях или некоторых мобильных браузерах (см. таблицу совместимости на странице, указанной выше), поэтому, если вам требуется поддержка этих браузеров, вы 'понадобится какой-нибудь запасной вариант:

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

Оригинальный ответ

Лучший способ сделать сравнение без учета регистра в JavaScript - это использовать RegExpmatch() метод сi флаг.

Поиск без учета регистра

Когда обе сравниваемые строки являются переменными (не константами), тогданемного сложнеепотому что вам нужно сгенерировать RegExp из строки, но передача строки в конструктор RegExp может привести к неправильным совпадениям или неудачным совпадениям, если в строке есть специальные символы регулярного выражения.

Если вы заботитесь о интернационализации, нет использоватьtoLowerCase() или жеtoUpperCase() как это не• обеспечить точное сравнение без учета регистра на всех языках.

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

если вас беспокоит направление неравенства (возможно, вы хотите отсортировать список), вам, скорее всего, нужно выполнить преобразование регистра, и, поскольку в юникоде больше строчных символов, чем заглавных, toLowerCase, вероятно, является лучшим преобразованием для использования.

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

Javascript, кажется, использует локаль "C" для сравнения строк, поэтому результирующее упорядочение будет некрасивым, если строки содержат не буквы ASCII. там'с этим мало что можно сделать, не проводя гораздо более детального осмотра строк.

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

Как сказано в последних комментариях,string::localCompare поддерживает сравнение без учета регистра (среди других важных вещей).

Вот'простой пример

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

И универсальная функция, которую вы могли бы использовать

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

Обратите внимание, что вместоundefined вам, вероятно, следует ввести конкретную локаль, с которой вы работаете. Это важно, как указано в документах MDN.

на шведском, ä и являются отдельными базовыми буквами

На момент публикации UC Browser для Android и Opera Miniне делайте служба поддержкиместо действия а такжеопции параметры. пожалуйста, проверьтеhttps://caniuse.com/#search=localeCompare для актуальной информации.

Недавно я создал микробиблиотеку, которая предоставляет регистронезависимые помощники строк:https://github.com/nickuraltsev/ignore-case, (Оно используетtoUpperCase внутренне.)

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

Существует два способа сравнения без учета регистра:

Использовать "поиск" строковый метод для поиска без учета регистра. Читайте о поиске и других строковых методах по адресу:http://www.thesstech.com/pattern-matching-using-string-methods

  
    
      

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

      
    

Помните, что оболочка - это операция, специфичная для локали В зависимости от сценария вы можете принять это во внимание. Например, если вы сравниваете имена двух людей, вы можете рассмотреть локаль, но если вы сравниваете сгенерированные машиной значения, такие как UUID, то вы можете этого не делать. Вот почему я использую следующую функцию в моей библиотеке утилит (обратите внимание, что проверка типа не включена по соображениям производительности).

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

С помощью регулярного выражения также мы можем достичь.

(/keyword/i).test(source)

/i для игнорирования дела. Если в этом нет необходимости, мы можем проигнорировать и проверить на НЕ совпадение с учетом регистра, например

(/keyword/).test(source)

Я написал расширение. очень тривиально

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

Здесь много ответов, но мне нравится добавлять решение, основанное на расширении библиотеки String:

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

Таким образом, вы можете использовать его так же, как в Java!

Пример:

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

Предположим, мы хотим найти строковую переменнуюneedle в строковой переменнойhaystack, Есть три ошибки:

Принимая во внимание пункты (1) и (2), примером будет:

var haystack = "A. BAIL. Of. Hay.";
var needle = "bail.";
var needleRegExp = new RegExp(needle.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\
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
}
amp;"), "i");
var result = needleRegExp.test(haystack);
if (result) {
    // Your code here
}