Как сделать сравнение строк без учета регистра?

Как выполнить сравнение строк без учета регистра в JavaScript?

Самый простой способ сделать это (если вас не беспокоят специальные символы Юникода) - это вызвать toUpperCase:

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

РЕДАКТИРОВАТЬ : Этот ответ был первоначально добавлен 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 - это использовать match()метод RegExp с iфлагом.

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

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

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

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

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

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

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

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

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

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

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

Варианты чувствительности

Поддержка браузера

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

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

(/keyword/i).test(source)

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

(/keyword/).test(source)

Помните, что оболочка - это операция, специфичная для локали. В зависимости от сценария вы можете принять это во внимание. Например, если вы сравниваете имена двух людей, вы можете рассмотреть локаль, но если вы сравниваете сгенерированные машиной значения, такие как 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;
}

Недавно я создал микробиблиотеку, в которой есть помощники для строк без учета регистра: 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

если вас беспокоит направление неравенства (возможно, вы хотите отсортировать список), вам, скорее всего, нужно выполнить преобразование регистра, и, поскольку в юникоде больше строчных символов, чем в верхнем, 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. с этим мало что можно сделать, не проводя гораздо более детального осмотра строк.

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

1. Интернационализированных приложений следует избегать string.toUpperCaseи string.toLowerCase. Используйте регулярное выражение, которое игнорирует регистр. Например, var needleRegExp = new RegExp(needle, "i");после needleRegExp.test(haystack).
2. В общем, вы можете не знать значение needle. Будьте осторожны, чтобы в needleрегулярных выражениях не было специальных символов . Побег это, используя needle.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");.
3. В других случаях, если вы хотите точно соответствовать needleи haystack, просто игнорируя регистр, обязательно добавьте "^"в начале и "$"в конце конструктор вашего регулярного выражения.

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

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
}

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

1. Преобразуйте строки в верхний регистр, а затем сравните их, используя строгий оператор ( ===). Как строгий оператор относится к операндам, читая материал по адресу: http://www.thesstech.com/javascript/relational-logical-operators
2. Сопоставление с шаблоном с использованием строковых методов:

Используйте строковый метод поиска для поиска без учета регистра. Читайте о поиске и других строковых методах по адресу: 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>

Здесь много ответов, но мне нравится добавлять решение, основанное на расширении библиотеки 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");
}

Используйте RegEx для совпадения строк или сравнения.

В JavaScript вы можете использовать match()для сравнения строк, не забудьте поставитьi в RegEx.

Пример:

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

Даже на этот вопрос уже ответили. У меня другой подход к использованию RegExp и match, чтобы игнорировать регистр символов. Пожалуйста, смотрите мою ссылку 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);

  }

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

Если обе строки имеют одну и ту же известную локаль, вы можете использовать Intl.Collatorобъект следующим образом:

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

Очевидно, что вы можете кэшировать Collatorдля повышения эффективности.

Преимущества этого подхода состоят в том, что он должен быть намного быстрее, чем использование RegExps, и основан на чрезвычайно настраиваемом (см. Описание localesи optionsпараметры конструктора в статье выше) готовом к использованию сборщике.

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

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

Как насчет НЕ выбрасывать исключения и НЕ использовать медленное регулярное выражение?

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

Приведенный выше фрагмент предполагает, что вы не хотите совпадать, если строка имеет значение null или не определена.

Если вы хотите сопоставить ноль / неопределенное, то:

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

Если по какой-то причине вы заботитесь о неопределенности против нуля:

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

Поскольку ни один ответ явно не предоставил простой фрагмент кода для использования RegExp, вот моя попытка:

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

У этого есть несколько преимуществ:

1. Проверяет тип параметра (любой нестроковый параметр, undefinedнапример, может привести к аварийному завершению выражения типа str1.toUpperCase()).
2. Не страдает от возможных проблем интернационализации.
3. Избегает RegExpстроки.

Это улучшенная версия из этого ответа .

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

Преобразуйте оба в нижний (только один раз по соображениям производительности) и сравните их с троичным оператором в одну строку:

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

Если вы знаете, что имеете дело с asciiтекстом, вы можете просто использовать сравнение смещения символов в верхнем и нижнем регистре.

Просто убедитесь, что строка вашей «идеальной» строки (с которой вы хотите сопоставить) строчная:

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

Мне нравится этот быстрый вариант стенографии -

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

Быстрая обработка и делает то, для чего она предназначена.

Эта javascript библиотека, кажется, обеспечивает много строковых операций. Это очень удобно использовать

Как установить

npm install --save string

Импортировать

var S = require('string');

Строка сравнения Ignorecase

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