Як зробити порівняння рядків нечутливих до регістру?

Як виконати порівняння рядків нечутливих до регістру в JavaScript?

Найпростіший спосіб зробити це (якщо вас не турбують спеціальні символи Unicode) - зателефонувати toUpperCase:

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

EDIT : Ця відповідь спочатку була додана 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=localeПорівняйте актуальну інформацію.

За допомогою регулярного вираження також ми можемо досягти.

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

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

Використовуйте рядовий метод "search" для нечутливого пошуку регістру. Про пошук та інші рядкові методи читайте на веб-сайті: 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()для порівняння рядків, не забудьте ввести iRegEx.

Приклад:

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

Якщо обидва рядки мають однакову відому локаль, ви можете скористатися 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();
     };
}

Навіть на це питання вже відповіли. У мене інший підхід використовувати 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);

  }

Як щодо НЕ кидання винятків і НЕ використання повільного регулярного вираження?

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

Вищенаведений фрагмент передбачає, що ви не хочете відповідати, якщо будь-яка рядок є нульовою або невизначеною.

Якщо ви хочете відповідати null / undefined, тоді:

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

Ігнорувати порівняння рядка

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