Aus der Mathematik kennen wir viele Vergleichsoperatoren.
In JavaScript werden sie so geschrieben:
Größer/kleiner als: a > b , a < b .
Größer/kleiner als oder gleich: a >= b , a <= b .
Gleicht: a == b . Bitte beachten Sie, dass das doppelte Gleichheitszeichen == den Gleichheitstest bedeutet, während ein einzelnes a = b eine Zuweisung bedeutet.
Nicht gleich: In der Mathematik lautet die Notation ≠ , aber in JavaScript wird sie als a != b geschrieben.
In diesem Artikel erfahren wir mehr über verschiedene Arten von Vergleichen, wie JavaScript sie durchführt, einschließlich wichtiger Besonderheiten.
Am Ende finden Sie ein gutes Rezept, um Probleme im Zusammenhang mit „JavaScript-Macken“ zu vermeiden.
Alle Vergleichsoperatoren geben einen booleschen Wert zurück:
true – bedeutet „ja“, „richtig“ oder „die Wahrheit“.
false – bedeutet „nein“, „falsch“ oder „nicht die Wahrheit“.
Zum Beispiel:
alarm( 2 > 1 ); // wahr (richtig) alarm( 2 == 1 ); // false (falsch) alarm( 2 != 1 ); // wahr (richtig)
Ein Vergleichsergebnis kann wie jeder andere Wert einer Variablen zugewiesen werden:
sei Ergebnis = 5 > 4; // das Ergebnis des Vergleichs zuweisen Warnung( Ergebnis); // WAHR
Um festzustellen, ob eine Zeichenfolge größer als eine andere ist, verwendet JavaScript die sogenannte „Wörterbuch“- oder „lexikografische“ Reihenfolge.
Mit anderen Worten: Zeichenfolgen werden Buchstabe für Buchstabe verglichen.
Zum Beispiel:
alarm( 'Z' > 'A' ); // WAHR alarm( 'Glow' > 'Glee' ); // WAHR alarm( 'Bee' > 'Be' ); // WAHR
Der Algorithmus zum Vergleichen zweier Zeichenfolgen ist einfach:
Vergleichen Sie das erste Zeichen beider Zeichenfolgen.
Wenn das erste Zeichen der ersten Zeichenfolge größer (oder kleiner) als das der anderen Zeichenfolge ist, ist die erste Zeichenfolge größer (oder kleiner) als die zweite. Wir sind fertig.
Andernfalls, wenn die ersten Zeichen beider Zeichenfolgen gleich sind, vergleichen Sie die zweiten Zeichen auf die gleiche Weise.
Wiederholen Sie den Vorgang bis zum Ende einer der beiden Zeichenfolgen.
Wenn beide Zeichenfolgen gleich lang enden, sind sie gleich. Andernfalls ist die längere Zeichenfolge größer.
Im ersten Beispiel oben führt der Vergleich 'Z' > 'A' im ersten Schritt zu einem Ergebnis.
Der zweite Vergleich 'Glow' und 'Glee' erfordert mehr Schritte, da Zeichenfolgen Zeichen für Zeichen verglichen werden:
G ist dasselbe wie G .
l ist dasselbe wie l .
o ist größer als e . Halten Sie hier an. Die erste Saite ist größer.
Kein echtes Wörterbuch, sondern Unicode-Reihenfolge
Der oben angegebene Vergleichsalgorithmus entspricht in etwa dem in Wörterbüchern oder Telefonbüchern verwendeten, ist jedoch nicht genau derselbe.
Zum Beispiel kommt es auf den Fall an. Ein Großbuchstabe "A" ist nicht gleich dem Kleinbuchstaben "a" . Welches ist größer? Der Kleinbuchstabe "a" . Warum? Da das Kleinbuchstabe einen größeren Index in der von JavaScript verwendeten internen Codierungstabelle hat (Unicode). Auf konkrete Details und Folgen davon gehen wir im Kapitel Strings noch einmal ein.
Beim Vergleich von Werten verschiedener Typen wandelt JavaScript die Werte in Zahlen um.
Zum Beispiel:
alarm( '2' > 1 ); // true, String '2' wird zu einer Zahl 2 alarm( '01' == 1 ); // true, String '01' wird zur Zahl 1
Bei booleschen Werten wird true zu 1 und false zu 0 .
Zum Beispiel:
alarm( true == 1 ); // WAHR alarm( false == 0 ); // WAHR
Eine lustige Konsequenz
Es ist möglich, dass gleichzeitig:
Zwei Werte sind gleich.
Einer davon ist als boolescher Wert true und der andere als boolescher Wert false .
Zum Beispiel:
sei a = 0; alarm( Boolean(a) ); // FALSCH sei b = „0“; alarm( Boolean(b) ); // WAHR alarm(a == b); // WAHR!
Aus JavaScript-Sicht ist dieses Ergebnis völlig normal. Eine Gleichheitsprüfung konvertiert Werte mithilfe der numerischen Konvertierung (daher wird "0" zu 0 ), während die explizite Boolean Konvertierung einen anderen Satz von Regeln verwendet.
Eine regelmäßige Gleichheitsprüfung == hat ein Problem. Es kann 0 von false nicht unterscheiden:
alarm( 0 == false ); // WAHR
Das Gleiche passiert mit einem leeren String:
alarm( '' == false ); // WAHR
Dies liegt daran, dass Operanden unterschiedlichen Typs durch den Gleichheitsoperator == in Zahlen umgewandelt werden. Eine leere Zeichenfolge wird, genau wie false , zu einer Null.
Was tun, wenn wir 0 von false unterscheiden möchten?
Ein strikter Gleichheitsoperator === prüft die Gleichheit ohne Typkonvertierung.
Mit anderen Worten: Wenn a und b unterschiedlichen Typs sind, gibt a === b sofort false zurück, ohne dass versucht wird, sie umzuwandeln.
Versuchen wir es:
alarm( 0 === false ); // false, da die Typen unterschiedlich sind
Es gibt auch einen „strikten Ungleichheits“-Operator !== analog zu != .
Der strikte Gleichheitsoperator ist etwas länger zu schreiben, macht aber deutlich, was vor sich geht, und lässt weniger Raum für Fehler.
Es gibt ein nicht intuitives Verhalten, wenn null oder undefined mit anderen Werten verglichen werden.
Für eine strikte Gleichheitsprüfung ===
Diese Werte sind unterschiedlich, da es sich bei jedem um einen anderen Typ handelt.
alarm( null === undefiniert ); // FALSCH
Für eine nicht strenge Prüfung ==
Es gibt eine Sonderregel. Diese beiden sind ein „süßes Paar“: Sie sind einander gleich (im Sinne von == ), haben aber keinen anderen Wert.
alarm( null == undefiniert ); // WAHR
Für Mathematik und andere Vergleiche < > <= >=
null/undefined werden in Zahlen umgewandelt: null wird zu 0 , während undefined zu NaN wird.
Sehen wir uns nun einige lustige Dinge an, die passieren, wenn wir diese Regeln anwenden. Und was noch wichtiger ist, wie man mit ihnen nicht in eine Falle tappt.
Vergleichen wir null mit einer Null:
alarm( null > 0 ); // (1) falsch alarm( null == 0 ); // (2) falsch alarm( null >= 0 ); // (3) wahr
Mathematisch gesehen ist das seltsam. Das letzte Ergebnis besagt, dass „ null größer oder gleich Null“ ist. In einem der obigen Vergleiche muss es also true sein, aber beide sind falsch.
Der Grund dafür ist, dass eine Gleichheitsprüfung == und Vergleiche > < >= <= unterschiedlich funktionieren. Vergleiche konvertieren null in eine Zahl und behandeln sie als 0 . Deshalb ist (3) null >= 0 wahr und (1) null > 0 falsch.
Andererseits ist die Gleichheitsprüfung == für undefined und null so definiert, dass sie ohne Konvertierungen einander gleich sind und nichts anderes. Deshalb ist (2) null == 0 falsch.
Der Wert undefined sollte nicht mit anderen Werten verglichen werden:
alarm( undefiniert > 0 ); // falsch (1) alarm( undefiniert < 0 ); // falsch (2) alarm( undefiniert == 0 ); // falsch (3)
Warum mag es Null so sehr? Immer falsch!
Wir erhalten diese Ergebnisse, weil:
Die Vergleiche (1) und (2) geben false zurück, da undefined in NaN konvertiert wird und NaN ein spezieller numerischer Wert ist, der bei allen Vergleichen false zurückgibt.
Die Gleichheitsprüfung (3) gibt false zurück, da undefined nur gleich null , undefined und keinem anderen Wert ist.
Warum haben wir diese Beispiele durchgegangen? Sollten wir uns ständig an diese Besonderheiten erinnern? Nun ja, nicht wirklich. Eigentlich werden Ihnen diese kniffligen Dinge mit der Zeit bekannt, aber es gibt eine gute Möglichkeit, Probleme damit zu vermeiden:
Behandeln Sie jeden Vergleich mit undefined/null mit Ausnahme der strikten Gleichheit === mit außerordentlicher Sorgfalt.
Verwenden Sie keine Vergleiche >= > < <= mit einer Variablen, die möglicherweise null/undefined ist, es sei denn, Sie sind sich wirklich sicher, was Sie tun. Wenn eine Variable diese Werte haben kann, prüfen Sie sie separat.
Vergleichsoperatoren geben einen booleschen Wert zurück.
Zeichenfolgen werden Buchstabe für Buchstabe in der „Wörterbuch“-Reihenfolge verglichen.
Wenn Werte unterschiedlichen Typs verglichen werden, werden sie in Zahlen umgewandelt (unter Ausschluss einer strikten Gleichheitsprüfung).
Die Werte null und undefined sind einander == und entsprechen keinem anderen Wert.
Seien Sie vorsichtig, wenn Sie Vergleiche wie > oder < mit Variablen verwenden, die gelegentlich null/undefined sein können. Es ist eine gute Idee, separat nach null/undefined zu suchen.
Wichtigkeit: 5
Was wird das Ergebnis für diese Ausdrücke sein?
5 > 4 „Apfel“ > „Ananas“ „2“ > „12“ undefiniert == null undefiniert === null null == "n0n" null === +"n0n"
5 > 4 → wahr „Apfel“ > „Ananas“ → falsch „2“ > „12“ → wahr undefiniert == null → wahr undefiniert === null → falsch null == "n0n" → falsch null === +"n0n" → falsch
Einige der Gründe:
Offensichtlich wahr.
Wörterbuchvergleich, daher falsch. "a" ist kleiner als "p" .
Auch hier ist im Wörterbuchvergleich das erste Zeichen "2" größer als das erste Zeichen "1" .
Die Werte null und undefined sind nur einander gleich.
Strikte Gleichheit ist streng. Unterschiedliche Typen auf beiden Seiten führen zu Falschmeldungen.
Ähnlich wie (4) ist null nur gleich undefined .
Strikte Gleichheit verschiedener Typen.