Wie wird ein String-Vergleich ohne Berücksichtigung der Groß- und Kleinschreibung durchgeführt?

Wie führe ich einen Vergleich von Zeichenfolgen ohne Berücksichtigung der Groß- und Kleinschreibung in JavaScript durch?

Der einfachste Weg, dies zu tun (wenn Sie sich keine Sorgen über spezielle Unicode-Zeichen machen), ist der Aufruf von toUpperCase:

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

EDIT : Diese Antwort wurde ursprünglich vor 9 Jahren hinzugefügt. Heute sollten Sie localeComparemit der sensitivity: 'accent'Option verwenden:

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

Das { sensitivity: 'accent' }sagt localeCompare(), dass zwei Varianten desselben Basisbuchstabens als gleich behandelt werden sollen, es sei denn, sie haben unterschiedliche Akzente (wie im dritten Beispiel) oben.

Alternativ können Sie verwenden { sensitivity: 'base' }, bei dem zwei Zeichen als gleichwertig behandelt werden, solange ihr Basiszeichen identisch ist (dies Awürde als gleichwertig behandelt werden á).

Beachten Sie, dass der dritte Parameter von localeComparein IE10 oder niedriger oder in bestimmten mobilen Browsern nicht unterstützt wird (siehe Kompatibilitätstabelle auf der oben verlinkten Seite). Wenn Sie diese Browser unterstützen müssen, benötigen Sie eine Art Fallback:

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

Ursprüngliche Antwort

Der beste Weg, einen Vergleich ohne Berücksichtigung der Groß- und Kleinschreibung in JavaScript durchzuführen, ist die Verwendung der RegExp- match()Methode mit dem iFlag.

Suche ohne Berücksichtigung der Groß- und Kleinschreibung

Wenn beide verglichenen Zeichenfolgen Variablen (keine Konstanten) sind, ist dies etwas komplizierter, da Sie aus der Zeichenfolge ein RegExp generieren müssen. Die Übergabe der Zeichenfolge an den RegExp-Konstruktor kann jedoch zu falschen Übereinstimmungen oder fehlgeschlagenen Übereinstimmungen führen, wenn die Zeichenfolge einen speziellen regulären Ausdruck aufweist Zeichen darin.

Wenn Sie sich über die Internationalisierung Pflege nicht verwenden toLowerCase()oder toUpperCase()wie es nicht genau Groß- und Kleinschreibung Vergleiche in allen Sprachen bietet.

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

Wie in jüngsten Kommentaren erwähnt, string::localeComparewerden Vergleiche ohne Berücksichtigung der Groß- und Kleinschreibung unterstützt (unter anderem leistungsstarke Dinge).

Hier ist ein einfaches Beispiel

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

Und eine generische Funktion, die Sie verwenden könnten

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

Beachten Sie, dass Sie stattdessen undefinedwahrscheinlich das spezifische Gebietsschema eingeben sollten, mit dem Sie arbeiten. Dies ist wichtig, wie in den MDN-Dokumenten angegeben

auf Schwedisch sind ä und a separate Basisbuchstaben

Empfindlichkeitsoptionen

Browser-Unterstützung

Zum Zeitpunkt der Buchung, UC Browser für Android und Opera Mini nicht unterstützt locale und Optionen Parameter. Aktuelle Informationen finden Sie unter https://caniuse.com/#search=localeCompare .

Mit Hilfe des regulären Ausdrucks können wir auch erreichen.

(/keyword/i).test(source)

/iist für den Fall ignorieren. Wenn nicht notwendig, können wir ignorieren und testen, ob keine Übereinstimmung zwischen Groß- und Kleinschreibung besteht

(/keyword/).test(source)

Denken Sie daran, dass das Gehäuse eine länderspezifische Operation ist. Je nach Szenario möchten Sie dies möglicherweise berücksichtigen. Wenn Sie beispielsweise Namen von zwei Personen vergleichen, möchten Sie möglicherweise das Gebietsschema berücksichtigen. Wenn Sie jedoch maschinengenerierte Werte wie UUID vergleichen, ist dies möglicherweise nicht der Fall. Aus diesem Grund verwende ich die folgende Funktion in meiner Utils-Bibliothek (beachten Sie, dass die Typprüfung aus Leistungsgründen nicht enthalten ist).

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

Ich habe kürzlich eine Mikrobibliothek erstellt, die String-Helfer ohne Berücksichtigung der Groß- und Kleinschreibung bereitstellt: https://github.com/nickuraltsev/ignore-case . (Es wird toUpperCaseintern verwendet.)

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

Wenn Sie sich Gedanken über die Richtung der Ungleichung machen (vielleicht möchten Sie eine Liste sortieren), müssen Sie so ziemlich die Groß- und Kleinschreibung konvertieren. Da Unicode mehr Kleinbuchstaben enthält als Großbuchstaben, ist LowCase wahrscheinlich die beste Konvertierung.

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

Javascript scheint das Gebietsschema "C" für Zeichenfolgenvergleiche zu verwenden, sodass die resultierende Reihenfolge hässlich ist, wenn die Zeichenfolgen andere als ASCII-Buchstaben enthalten. Es kann nicht viel dagegen getan werden, ohne die Saiten genauer zu untersuchen.

Angenommen, wir möchten die Zeichenfolgenvariable needlein der Zeichenfolgenvariablen finden haystack. Es gibt drei Fallstricke:

1. Internationalisierte Anwendungen sollten string.toUpperCaseund vermeiden string.toLowerCase. Verwenden Sie stattdessen einen regulären Ausdruck, bei dem Groß- und Kleinschreibung ignoriert wird. Zum Beispiel var needleRegExp = new RegExp(needle, "i");gefolgt von needleRegExp.test(haystack).
2. Im Allgemeinen kennen Sie den Wert von möglicherweise nicht needle. Achten Sie darauf, dass needlekeine Sonderzeichen für reguläre Ausdrücke enthalten sind . Entkomme diesen mit needle.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");.
3. In anderen Fällen, wenn Sie genau übereinstimmen needleund haystackdie Groß- und Kleinschreibung ignorieren möchten , stellen Sie sicher, dass Sie sie "^"am Anfang und "$"am Ende Ihres Konstruktors für reguläre Ausdrücke hinzufügen .

Unter Berücksichtigung der Punkte (1) und (2) wäre ein Beispiel:

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
}

Es gibt zwei Möglichkeiten für einen Vergleich ohne Berücksichtigung der Groß- und Kleinschreibung:

1. Konvertieren Sie Zeichenfolgen in Großbuchstaben und vergleichen Sie sie dann mit dem strengen Operator ( ===). Wie streng Operatoren mit Operanden umgehen, lesen Sie unter: http://www.thesstech.com/javascript/relational-logical-operators
2. Mustervergleich mit String-Methoden:

Verwenden Sie die Zeichenfolgenmethode "search" für die Suche ohne Berücksichtigung der Groß- und Kleinschreibung. Weitere Informationen zur Suche und zu anderen Zeichenfolgenmethoden finden Sie unter: 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>

Viele Antworten hier, aber ich möchte eine Lösung hinzufügen, die auf der Erweiterung der String-Bibliothek basiert:

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

Auf diese Weise können Sie es einfach wie in Java verwenden!

Beispiel:

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

Ausgabe wird sein:

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

Verwenden Sie RegEx für die Übereinstimmung oder den Vergleich von Zeichenfolgen.

In JavaScript können Sie match()für den Zeichenfolgenvergleich verwenden. Vergessen Sie nicht, iRegEx einzugeben.

Beispiel:

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

Wenn beide Zeichenfolgen dasselbe bekannte Gebietsschema haben, möchten Sie möglicherweise ein Intl.CollatorObjekt wie das folgende verwenden:

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

Offensichtlich möchten Sie das Collatorfür eine bessere Effizienz zwischenspeichern.

Der Vorteil dieses Ansatzes besteht darin, dass er viel schneller als die Verwendung von RegExps sein sollte und auf einem äußerst anpassbaren Satz gebrauchsfertiger Kollatatoren basiert (siehe Beschreibung localesund optionsKonstruktorparameter im obigen Artikel).

Ich habe eine Erweiterung geschrieben. sehr trivial

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

Auch diese Frage hat sich bereits beantwortet. Ich habe einen anderen Ansatz, um RegExp und Match zu verwenden, um Groß- und Kleinschreibung zu ignorieren. Bitte beachten Sie meinen 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);

  }

Wie wäre es, KEINE Ausnahmen auszulösen und KEINEN langsamen regulären Ausdruck zu verwenden?

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

Das obige Snippet setzt voraus, dass Sie nicht übereinstimmen möchten, wenn eine der Zeichenfolgen null oder undefiniert ist.

Wenn Sie mit null / undefiniert übereinstimmen möchten, dann:

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

Wenn Sie sich aus irgendeinem Grund für undefined vs null interessieren:

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

Da keine Antwort eindeutig ein einfaches Code-Snippet zur Verwendung lieferte RegExp, ist hier mein Versuch:

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

Es hat mehrere Vorteile:

1. Überprüft den Parametertyp (alle Nicht-String-Parameter wie z undefined zum Beispiel, würde einen Ausdruck wie zum Absturz bringen str1.toUpperCase()).
2. Leidet nicht unter möglichen Internationalisierungsproblemen.
3. Entkommt der RegExpZeichenfolge.

Dies ist eine verbesserte Version von dieser Antwort .

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

Konvertieren Sie beide in niedrigere (aus Leistungsgründen nur einmal) und vergleichen Sie sie mit dem ternären Operator in einer einzigen Zeile:

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

Wenn Sie wissen, dass Sie mit asciiText zu tun haben , können Sie einfach einen Versatzvergleich zwischen Groß- und Kleinbuchstaben verwenden.

Stellen Sie einfach sicher, dass die Zeichenfolge, mit der Ihre "perfekte" Zeichenfolge (die Sie vergleichen möchten), klein geschrieben ist:

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

Ich mag diese schnelle Kurzvariante -

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

Schnell in der Verarbeitung und macht, was es beabsichtigt.

Diese javascript Bibliothek scheint viele Zeichenfolgenoperationen bereitzustellen. Es ist sehr bequem zu bedienen

Wie installiert man

npm install --save string

Importieren

var S = require('string');

Ignorecase Compare String

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