Jak porównać ciąg znaków bez rozróżniania wielkości liter?

Jak przeprowadzić porównanie ciągów znaków bez rozróżniania wielkości liter w JavaScript?

Najprostszym sposobem, aby to zrobić (jeśli nie martwisz się o znaki specjalne Unicode), jest wywołanie toUpperCase:

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

EDYCJA : Ta odpowiedź została pierwotnie dodana 9 lat temu. Dzisiaj powinieneś używać localeComparez sensitivity: 'accent'opcją:

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' }Mówi localeCompare()traktować dwa warianty tego samego listu bazowej jako taki sam , chyba że mają różne akcenty (jak w trzecim przykładzie) powyżej.

Alternatywnie możesz użyć { sensitivity: 'base' }, który traktuje dwie postacie jako równoważne, o ile ich podstawowy znak jest taki sam (więc Abyłoby traktowane jako równoważne á).

Pamiętaj, że trzeci parametr parametru localeComparenie jest obsługiwany w przeglądarce IE10 lub nowszej lub w niektórych przeglądarkach mobilnych (zobacz tabelę kompatybilności na powyższej stronie), więc jeśli potrzebujesz obsługi tych przeglądarek, potrzebujesz pewnego rodzaju rezerwy:

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

Oryginalna odpowiedź

Najlepszym sposobem na dokonanie porównania bez rozróżniania wielkości liter w JavaScript jest użycie match()metody RegExp z iflagą.

Wyszukiwanie bez rozróżniania wielkości liter

Gdy oba porównywane ciągi są zmiennymi (a nie stałymi), jest to nieco bardziej skomplikowane, ponieważ musisz wygenerować RegExp z ciągu, ale przekazanie ciągu do konstruktora RegExp może spowodować niepoprawne dopasowanie lub nieudane dopasowanie, jeśli ciąg ma specjalne wyrażenie regularne znaki w nim.

Jeśli dbasz o umiędzynarodowienie nie używać toLowerCase()albo toUpperCase()jak nie dostarcza dokładnych case-niewrażliwe porównań we wszystkich językach.

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

Jak powiedziano w ostatnich komentarzach, string::localeCompareobsługuje porównania bez rozróżniania wielkości liter (między innymi ważnymi rzeczami).

Oto prosty przykład

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

I ogólna funkcja, której możesz użyć

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

Zauważ, że zamiast tego undefinedpowinieneś prawdopodobnie wprowadzić określone ustawienia regionalne, z którymi pracujesz. Jest to ważne, jak wskazano w dokumentach MDN

w języku szwedzkim ä i a to osobne litery podstawowe

Opcje czułości

Obsługa przeglądarki

W chwili publikacji UC Browser dla Androida i Opera Mini nie obsługują ustawień regionalnych i parametrów opcji . Sprawdź https://caniuse.com/#search=localeCompare , aby uzyskać aktualne informacje.

Z pomocą wyrażeń regularnych możemy również osiągnąć.

(/keyword/i).test(source)

/ijest dla ignorowania wielkości liter. Jeśli nie jest to konieczne, możemy zignorować i przetestować pod kątem NIE rozróżniania wielkich i małych liter

(/keyword/).test(source)

Pamiętaj, że obudowa jest operacją zależną od ustawień regionalnych. W zależności od scenariusza możesz wziąć to pod uwagę. Na przykład, jeśli porównujesz nazwiska dwóch osób, możesz rozważyć ustawienia regionalne, ale jeśli porównujesz wartości generowane maszynowo, takie jak UUID, możesz tego nie zrobić. Dlatego używam następującej funkcji w mojej bibliotece utils (zauważ, że sprawdzanie typu nie jest uwzględnione ze względu na wydajność).

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

Niedawno utworzyłem mikro bibliotekę, która zapewnia pomocniki bez rozróżniania wielkości liter: https://github.com/nickuraltsev/ignore-case . (Wykorzystuje toUpperCasewewnętrznie.)

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

jeśli martwisz się kierunkiem nierówności (być może chcesz posortować listę), prawie musisz przeprowadzić konwersję wielkości liter, a ponieważ w kodzie Unicode jest więcej małych liter niż wielkich liter, to prawdopodobnie najlepsza konwersja do użycia.

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

Wygląda na to, że JavaScript używa ustawień regionalnych „C” do porównywania ciągów, więc wynikowe uporządkowanie będzie brzydkie, jeśli ciągi zawierają inne niż litery ASCII. niewiele można z tym zrobić bez dokładniejszej kontroli napisów.

Załóżmy, że chcemy znaleźć zmienną needlełańcuchową w zmiennej łańcuchowej haystack. Istnieją trzy gotcha:

1. Międzynarodowe aplikacje powinny unikać string.toUpperCasei string.toLowerCase. Zamiast tego użyj wyrażenia regularnego, które ignoruje wielkość liter. Na przykład, var needleRegExp = new RegExp(needle, "i");po którym następujeneedleRegExp.test(haystack) .
2. Ogólnie rzecz biorąc, możesz nie znać wartości needle. Uważaj, aby needlenie zawierało żadnych znaków specjalnych wyrażeń regularnych . Ucieczka za pomocąneedle.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"); .
3. W innych przypadkach, jeśli chcesz dokładnie dopasować needlei haystack, po prostu ignorując "^"wielkość liter, upewnij się, że dodajesz na początku i "$"na końcu konstruktora wyrażeń regularnych.

Biorąc pod uwagę punkty (1) i (2), przykładem może być:

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
}

Istnieją dwa sposoby porównywania bez rozróżniania wielkości liter:

1. Konwertuj ciągi znaków na wielkie litery, a następnie porównuj je za pomocą ścisłego operatora ( ===). Jak surowy operator traktuje operandy czytać rzeczy na: http://www.thesstech.com/javascript/relational-logical-operators
2. Dopasowywanie wzorców za pomocą metod łańcuchowych:

Użyj metody „szukaj” w celu wyszukiwania bez rozróżniania wielkości liter. Przeczytaj o wyszukiwaniu i innych metodach ciągów na: 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>

Tutaj jest wiele odpowiedzi, ale lubię dodawać rozwiązanie oparte na rozszerzeniu lib String:

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

W ten sposób możesz po prostu używać go tak jak w Javie!

Przykład:

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

Dane wyjściowe będą:

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

Użyj RegEx do dopasowania ciągu lub porównania.

W JavaScript możesz używać match()do porównywania ciągów, nie zapomnij wstawići RegEx.

Przykład:

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

Jeśli oba ciągi znaków mają takie same znane ustawienia narodowe, możesz chcieć użyć Intl.Collatorobiektu takiego:

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

Oczywiście możesz chcieć buforować Collatordla lepszej wydajności.

Zaletą tego podejścia jest to, że powinno być znacznie szybsze niż użycie RegExps i opiera się na niezwykle konfigurowalnym (patrz opis localesi optionsparametry konstruktora w powyższym artykule) zestawie gotowych do użycia kolektorów.

Napisałem rozszerzenie. bardzo trywialne

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

Nawet na to pytanie już udzielono odpowiedzi. Mam inne podejście do używania RegExp i dopasowywania, aby ignorować wielkość liter. Proszę zobaczyć mój link 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);

  }

Co powiesz na NIE zgłaszanie wyjątków i NIE używanie powolnego wyrażenia regularnego?

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

Powyższy fragment zakłada, że ​​nie chcesz dopasowywać, jeśli dowolny ciąg ma wartość NULL lub jest niezdefiniowany.

Jeśli chcesz dopasować wartość null / undefined, to:

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

Jeśli z jakiegoś powodu zależy Ci na niezdefiniowanym kontra zerowym:

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

Ponieważ żadna odpowiedź nie zawierała prostego fragmentu kodu do użycia RegExp, oto moja próba:

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

Ma kilka zalet:

1. Weryfikuje typ parametru (dowolny parametr nieciągowy, taki jak undefinedna przykład, spowodowałby awarię wyrażenia podobnegostr1.toUpperCase() ).
2. Nie ma problemów z internacjonalizacją.
3. Ucieka z RegExpciągu.

Jest to ulepszona wersja od tej odpowiedzi .

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

Konwertuj oba na niższe (tylko raz ze względu na wydajność) i porównaj je z operatorem trójskładnikowym w jednym wierszu:

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

Jeśli wiesz, że masz do czynienia z asciitekstem, możesz po prostu użyć porównania przesunięcia wielkich i małych liter.

Upewnij się tylko, że ciąg „idealny” (ten, z którym chcesz się dopasować) jest pisany małymi literami:

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

Podoba mi się ta szybka stenografia -

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

Szybkie przetwarzanie i robi to, co jest przeznaczone.

To javascript biblioteka wydaje się zapewniać wiele operacji na łańcuchach znaków. Jest bardzo wygodny w użyciu

Jak zainstalować

npm install --save string

Import

var S = require('string');

Ignoruj ​​Porównaj ciąg

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