Vergleiche

Viele Vergleichsoperatoren kennen wir aus der Mathematik.

In JavaScript werden sie so geschrieben:

• Größer/kleiner als: a > b, a < b.
• Größer/kleiner als oder gleich: a >= b, a <= b.
• Gleich: a == b, bitte beachten Sie, dass das doppelte Gleichheitszeichen == die Gleichheitsprüfung bedeutet, während ein einzelnes a = b eine Zuordnung 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 mit „JavaScript-Macken“ zu vermeiden.

Boolean ist das Ergebnis

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:

alert( 2 > 1 ); // true (correct)alert( 2 == 1 ); // false (wrong)alert( 2 != 1 ); // true (correct)

Ein Vergleichsergebnis kann einer Variablen zugewiesen werden, wie jeder andere Wert auch:

let result = 5 > 4; // assign the result of the comparisonalert( result ); // true

Zeichenfolgenvergleich

Um festzustellen, ob eine Zeichenfolge größer als eine andere ist, verwendet JavaScript die sogenannte „Wörterbuch“- oder „lexikografische“ Reihenfolge.

Mit anderen Worten, Zeichenketten werden Buchstabe für Buchstabe verglichen.

Zum Beispiel:

alert( 'Z' > 'A' ); // truealert( 'Glow' > 'Glee' ); // truealert( 'Bee' > 'Be' ); // true

Der Algorithmus zum Vergleich zweier Zeichenketten ist einfach:

1. Vergleichen Sie das erste Zeichen beider Zeichenketten.
2. Wenn das erste Zeichen der ersten Zeichenfolge größer (oder kleiner) ist als das der anderen Zeichenfolge, dann ist die erste Zeichenfolge größer (oder kleiner) als die zweite. Das war’s.
3. Ansonsten, wenn die ersten Zeichen beider Zeichenketten gleich sind, vergleiche die zweiten Zeichen auf die gleiche Weise.
4. Wiederhole den Vorgang bis zum Ende einer der beiden Zeichenketten.
5. Wenn beide Zeichenketten mit der gleichen Länge enden, dann sind sie gleich. Andernfalls ist die längere Zeichenkette größer.

Im ersten Beispiel oben kommt der Vergleich 'Z' > 'A' im ersten Schritt zu einem Ergebnis.

Der zweite Vergleich 'Glow' und 'Glee' benötigt mehr Schritte, da die Zeichenfolgen Zeichen für Zeichen verglichen werden:

1. G ist gleich G.
2. l ist gleich l.
3. o ist größer als e. Hier aufhören. Die erste Zeichenkette ist größer.

Vergleich verschiedener Typen

Beim Vergleich von Werten verschiedener Typen konvertiert JavaScript die Werte in Zahlen.

Zum Beispiel:

alert( '2' > 1 ); // true, string '2' becomes a number 2alert( '01' == 1 ); // true, string '01' becomes a number 1

Für boolesche Werte wird true zu 1 und false zu 0.

Zum Beispiel:

alert( true == 1 ); // truealert( false == 0 ); // true

let a = 0;alert( Boolean(a) ); // falselet b = "0";alert( Boolean(b) ); // truealert(a == b); // true!

Strenge Gleichheit

Eine reguläre Gleichheitsprüfung == hat ein Problem. Sie kann 0 nicht von false unterscheiden:

alert( 0 == false ); // true

Das Gleiche passiert mit einer leeren Zeichenfolge:

alert( '' == false ); // true

Dies geschieht, weil Operanden unterschiedlichen Typs durch den Gleichheitsoperator == in Zahlen umgewandelt werden. Eine leere Zeichenkette wird, genau wie false, zu einer Null.

Was tun, wenn wir 0 von false unterscheiden wollen?

Ein strenger Gleichheitsoperator === prüft die Gleichheit ohne Typumwandlung.

Mit anderen Worten, wenn a und b von unterschiedlichem Typ sind, dann gibt a === b sofort false zurück, ohne den Versuch, sie zu konvertieren.

Versuchen wir es:

alert( 0 === false ); // false, because the types are different

Es gibt auch einen „strengen Nicht-Gleichheits“-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.

Vergleich mit null und undefiniert

Es gibt ein nicht intuitives Verhalten, wenn null oder undefined mit anderen Werten verglichen werden.

Für eine strenge Gleichheitsprüfung===

Diese Werte sind unterschiedlich, weil jeder von ihnen ein anderer Typ ist.

alert( null === undefined ); // false

Für eine nicht strenge Prüfung==

Es gibt eine besondere Regel. Diese beiden sind ein „süßes Paar“: Sie sind einander gleich (im Sinne von ==), aber keinem anderen Wert.

alert( null == undefined ); // true

Für Mathematik und andere Vergleiche werden< > <= >=

null/undefined in Zahlen umgewandelt: null wird zu 0, während undefined zu NaN wird.

Nun sehen wir uns einige lustige Dinge an, die passieren, wenn wir diese Regeln anwenden. Und, was noch wichtiger ist, wie man damit nicht in eine Falle tappt.

Kurioses Ergebnis: Null vs. 0

Lassen Sie uns null mit einer Null vergleichen:

alert( null > 0 ); // (1) falsealert( null == 0 ); // (2) falsealert( null >= 0 ); // (3) true

alert( undefined > 0 ); // false (1)alert( undefined < 0 ); // false (2)alert( undefined == 0 ); // false (3)