webentwicklung-frage-antwort-db.com.de

String-Vergleich ohne Berücksichtigung der Groß- und Kleinschreibung in JavaScript

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

827
flybywire

Der einfachste Weg, dies zu tun (wenn Sie sich keine Sorgen um spezielle Unicode-Zeichen machen), ist toUpperCase aufzurufen:

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

EDIT: Diese Antwort wurde ursprünglich vor 9 Jahren hinzugefügt. Heute sollten Sie localeCompare mit 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'));

Der { sensitivity: 'accent' } weist localeCompare() an, zwei Varianten desselben Basisbuchstabens als sofern nicht zu behandeln, da sie (wie im dritten Beispiel) unterschiedliche Akzente haben.

Alternativ können Sie { sensitivity: 'base' } verwenden, wobei zwei Zeichen als äquivalent behandelt werden, solange ihr Basiszeichen das gleiche ist (also würde A als äquivalent zu á behandelt werden).

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

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

Die beste Methode, um einen Vergleich ohne Berücksichtigung der Groß- und Kleinschreibung in JavaScript durchzuführen, ist die Verwendung der RegExp match()-Methode mit dem Flag i

Suche nach Groß- und Kleinschreibung

Wenn beide verglichenen Zeichenfolgen Variablen sind (keine Konstanten), ist dies etwas komplizierter, da Sie aus der Zeichenfolge 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 Regex hat Zeichen darin.

Wenn Sie sich für Internationalisierung interessieren, verwenden Sie nicht toLowerCase() oder toUpperCase(), da diese nicht in allen Sprachen genaue Vergleiche zwischen Groß- und Kleinschreibung ermöglicht.

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

125
Samuel Neff

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

(/keyword/i).test(source)

/i ist für den Fall ignoriert. Wenn dies nicht notwendig ist, können wir ignorieren und auf NICHT case sensitive Übereinstimmung prüfen

(/keyword/).test(source)
29
SP007

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 die Ländereinstellung berücksichtigen. Wenn Sie jedoch maschinengenerierte Werte wie die UUID vergleichen, ist dies möglicherweise nicht der Fall. Deshalb verwende ich folgende Funktion in meiner Utils-Bibliothek (Beachten Sie, dass die Typüberprü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;
}
26
Shital Shah

Wie in jüngsten Kommentaren gesagt, string::localCompare unterstützt Vergleiche ohne Berücksichtigung der Groß- und Kleinschreibung (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 anstelle von undefined wahrscheinlich das spezifische Gebietsschema eingeben sollten, mit dem Sie arbeiten. Dies ist wichtig, wie in den MDN-Dokumenten angegeben

auf Schwedisch sind ä und a separate Grundbuchstaben

Empfindlichkeitsoptionen

Sensitivity options tabulated from MDN

Browser-Unterstützung

Zum Zeitpunkt der Veröffentlichung, UC-Browser für Android und Opera Mini nicht Unterstützung Gebietsschema und Optionen Bitte überprüfen Sie https : //caniuse.com/#search=localeCompare für aktuelle Informationen.

17
jay

Ich habe vor kurzem eine Mikrobibliothek erstellt, die Zeichenfolgen-Helfer ohne Berücksichtigung der Groß- und Kleinschreibung enthält: https://github.com/nickuraltsev/ignore-case . (Es verwendet intern 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
10
Nick Uraltsev

wenn Sie über die Richtung der Ungleichheit besorgt sind (vielleicht möchten Sie eine Liste sortieren) .__ müssen Sie die Groß-/Kleinschreibung durchführen, und da in Unicode mehr Kleinbuchstaben als Großbuchstaben verwendet werden, ist ToLowerCase wahrscheinlich die beste Konvertierung benutzen.

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, so dass die resultierende Reihenfolge ungünstig ist, wenn die Zeichenfolgen andere Zeichen als ASCII enthalten. Es gibt nicht viel zu tun, ohne die Saiten viel genauer untersuchen zu müssen.

9
Jasen

Angenommen, wir möchten die Zeichenfolgenvariable needle in der Zeichenfolgenvariablen haystack suchen. Es gibt drei Fallstricke:

  1. Internationalisierte Anwendungen sollten string.toUpperCase und string.toLowerCase vermeiden. Verwenden Sie einen regulären Ausdruck, der stattdessen Groß- und Kleinschreibung ignoriert. Zum Beispiel var needleRegExp = new RegExp(needle, "i");, gefolgt von needleRegExp.test(haystack).
  2. Im Allgemeinen kennen Sie den Wert von needle möglicherweise nicht. Achten Sie darauf, dass needle keine regulären Ausdrücke Sonderzeichen enthält. Entkommen Sie diesen mit needle.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");.
  3. Wenn Sie in anderen Fällen needle und haystack genau übereinstimmen möchten, indem Sie die Groß- und Kleinschreibung ignorieren, müssen Sie unbedingt "^" am Anfang und "$" am Ende Ihres regulären Ausdruckskonstruktors 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
}
5
Chris Chute

Viele Antworten hier, aber ich füge gerne eine Lösung hinzu, die auf der Erweiterung der String lib 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");
}

4
Nebulosar

Es gibt zwei Möglichkeiten für den Vergleich zwischen Groß- und Kleinschreibung:

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

Verwenden Sie die String-Methode "search" für die Suche nach Groß- und Kleinschreibung. __ Lesen Sie die Suchmethoden und andere String-Methoden 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>
4
Sohail Arif
str = 'Lol', str2 = 'lOl', regex = new RegExp('^' + str + '$', 'i');
if (regex.test(str)) {
    console.log("true");
}
3
Parth Raval

regex für String-Vergleich oder Vergleich verwenden, 

In JavaScript können Sie match () für den Vergleich von Zeichenfolgen verwenden Vergessen Sie nicht, i in Regex zu setzen. 

beispiel: 

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

Wie wäre es, KEINE Ausnahmen zu werfen und KEINE langsamen Regex zu verwenden?

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

Bei dem obigen Snippet wird davon ausgegangen, dass Sie nicht übereinstimmen möchten, wenn eine Zeichenfolge null oder nicht definiert ist.

Wenn Sie mit null/undefined übereinstimmen möchten, gilt Folgendes:

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());
2
Ben Wilde

Auch diese Frage haben schon beantwortet. Ich habe einen anderen Ansatz, um RegExp und match zu verwenden, um die Groß- und Kleinschreibung zu ignorieren. Bitte sehen 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);

  }
2
David S Lee

Ich habe eine Erweiterung geschrieben. sehr trivial

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

Wenn beide Zeichenfolgen dasselbe bekannte Gebietsschema aufweisen, können Sie das Intl.Collator object wie folgt verwenden:

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

Natürlich sollten Sie die Collator für eine bessere Effizienz zwischenspeichern.

Der Vorteil dieses Ansatzes besteht darin, dass er viel schneller sein sollte als mit RegExps und basiert auf einem extrem anpassbaren Satz von einsatzbereiten Collators (siehe Beschreibung der Konstruktorparameter locales und options im obigen Artikel).

1

Da keine Antwort eindeutig ein einfaches Code-Snippet für die Verwendung von RegExp enthielt, ist hier mein Versuch:

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

Das hat mehrere Vorteile:

  1. Überprüft den Parametertyp (alle Nicht-String-Parameter, wie zum Beispiel undefined, würden einen Ausdruck wie str1.toUpperCase() zum Absturz bringen).
  2. Leidet nicht unter möglichen Internationalisierungsproblemen.
  3. Entfernt die RegExp-Zeichenfolge.
1
Ohad Schneider

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



Anwendungen & Tests:

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

0
Sergey

Konvertieren Sie beide in einen niedrigeren Wert (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);
}
0
Luca C.