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

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

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

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

JQuery, чтобы получить все переключатели в форма и проверенное значение. { 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 — это использовать RegExp match() метод с i Вы можете добавить это в свой прототип строки, что позволит вам

нечувствительным к регистру поиском

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

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

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

LP регулярного выражения и мы можем достичь.

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

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

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

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

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

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

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

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

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

Sensitivity options tabulated from MDN

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

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

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

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

Предположим, мы хотим найти строку переменная 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. Используйте строковый метод «search» для case нечувствительный поиск. Читайте о поиске и других строковых методах по адресу:

http://www.thesstech.com/pattern-matching-using-string-methods Здесь много ответов, но мне нравится добавлять решение на основе о расширении библиотеки String:

<!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>

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

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");
}
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");
}
str = 'Lol', str2 = 'lOl', regex = new RegExp('^'   str   '$', 'i');
if (regex.test(str)) {
    console.log("true");
}

Даже на этот вопрос уже ответили. У меня другой подход к использованию RegExp и match, чтобы игнорировать регистр символов. Пожалуйста, смотрите мою ссылку

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

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

  }

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

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

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

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

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

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

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

В JavaScript вы можете использовать

для сравнения строк, не забудьте поместить match() в RegEx. i Поскольку ни один ответ явно не предоставил простой фрагмент кода для использования

Пример:

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

, вот моя попытка: 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 Если обе строки имеют одну и ту же известную локаль, вы можете использовать объект

, например: Intl.Collator, для повышения эффективности.

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

. Это делается путем анализа шаблона руля и преобразования его в Collator параметры конструктора в статье выше) набор готовых коллатеров.

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

Это из использования & amp ; тестов: . Он включает интерфейс на основе Java, который определяет URL-адреса и упрощает доступ к ним. Глядя на вывод

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

javascript — создание даты с заданным часовым поясом без использования строкового представления — переполнение стека

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