JavaScript/Operatoren/Vergleichsoperatoren

Vergleichsoperatoren dienen zum Vergleichen zweier Werte. Solche Vergleiche werden vor allem für bedingte Anweisungen und Schleifen benutzt. Als Ergebnis liefern Vergleichsoperatoren immer einen sogenannten booleschen Wert (Wahrheitswert) vom Typ boolean, d. h. entweder true (wahr) oder false (falsch).

Sie können z. B. den Inhalt einer Variablen mit dem Inhalt einer anderen oder mit dem Ergebnis eines Ausdrucks vergleichen, indem Sie den gewünschten Vergleichsoperator zwischen den beiden Operanden notieren:

für Vergleiche

var sinnDesLebens = 42, alter = 8;

if (sinnDesLebens == 42) alert("Richtig.");
if (sinnDesLebens != 42) alert("Falsch.");
if (sinnDesLebens > 42)  alert("Falsch.");
if (sinnDesLebens < 42)  alert("Falsch.");
if (alter >= 18)         alert("SIE duerfen das hier sehen.");
if (alter <= 17)         alert("SIE duerfen das hier NICHT sehen.");

Im Beispiel werden die Inhalte der Variablen sinnDesLebens und alter mit fixen numerischen Werten (42 etc.) verglichen. Informationen zur Funktionsweise einer If-Abfrage finden Sie im Abschnitt über bedingte Anweisungen.

Notieren Sie für Vergleichsoperatoren das Gleichheitszeichen, das Ausrufezeichen, das Größerzeichen oder das Kleinerzeichen bzw. Kombinationen davon wie folgt:

Operator	Bedeutung	Ergebnis der Operation
==	istgleich	true, wenn die Werte gleich sind, sonst false.
!=	ungleich	true, wenn die Werte ungleich sind, sonst false.
>	größer	true, wenn der linke Wert größer als der rechte ist, sonst false.
>=	größergleich	true, wenn der linke Wert größer oder gleich dem rechten ist, sonst false.
<	kleiner	true, wenn der linke Wert kleiner als der rechte ist , sonst false.
<=	kleinergleich	true, wenn der linke Wert kleiner oder gleich dem rechten ist, sonst false.

Beachten Sie: Anweisungen mit einfachem Gleichheitszeichen sind Wertzuweisungen, bei denen der auf der rechten Seite stehende Donator seinen Wert an den auf der linken Seite stehenden Akzeptor übergibt.

Äpfel mit Birnen vergleichen

Die genannten Vergleichsoperatoren führen ggf. vor dem eigentlichen Vergleich unmerklich eine Typumwandlung durch. Das bedeutet, dass zwei Werte auch dann sinnvoll verglichen werden können, wenn es sich um unterschiedliche Datentypen handelt. Die Anweisung

alert(42 == "42");

gibt z. B. "true" aus, obwohl hier eine Zahl (Typ number) mit einer Zeichenkette (Typ string) verglichen wird.

Im Detail werden dabei folgende Regeln angewendet:

• Die Operatoren == und != betrachten die Werte null und undefined als gleich.
• Wenn die Operatoren == oder != eine Zahl, eine Zeichenkette oder ein Symbol mit einem Objekt vergleichen sollen, wird das Objekt zunächst in seinen primitiven Wert konvertiert
• Die Operatoren <, <=, > und >= ermitteln vor dem Vergleich zunächst den primitiven Wert ihrer Operanden. Für Operanden, die bereits einen primitiven Typ haben, hat das keine Auswirkung.
• Ein Booleanwert wird vor einem Vergleich zunächst in eine Zahl konvertiert
• Der Vergleich einer Zahl (Number oder BigInt) mit einer Zeichenkette wird so ausgeführt, dass die Zeichenkette zunächst in eine Zahl gleichen Typs konvertiert wird
• Der Vergleich zweier Zeichenketten erfolgt zeichenweise (d.h. gemäß dem Wert von charCodeAt) von links nach rechts. Die erweiterten Gleichheitsregeln des Unicode-Standards finden keine Anwendung, eine Unicode-Normalisierung findet nicht statt.
• Werden zwei Werte vom Datentyp object miteinander verglichen, dann
  • führen die Operatoren == und != einen strikten Vergleich aus (Gleichheit besteht nur, wenn beide Werte das gleiche Objekt bezeichnen)
  • vergleichen <, <=, > und >= den primitiven Wert. In den meisten Fällen führt das zum Vergleich von Strings wie [object Array], es sei denn, das Objekt implementiert valueOf oder toString so, dass sinnvollere primitive Werte gebildet werden
• Bei Vergleichen mit dem Wert NaN (Not a Number) liefert der ungleich-Operator != immer true, alle anderen immer false. Sogar der Vergleich NaN == NaN ergibt false, d. h. NaN ist nicht mit sich selbst gleich. Den Wert NaN können Sie mit der isNaN-Funktion erkennen</source>

Eine Folge dieser Regeln ist beispielsweise, dass das folgende Codestück nur die Meldung "a ist truthy" ausgibt. Die zweite Meldung "a ist gleich true" kommt nicht.

let a = "b";
if (a) {
  console.log("a ist truthy");
}

if (a == true) {
  console.log("a ist gleich true");
}

Grund ist, dass hier die einfachen Regeln für truthy und falsy nicht greifen. Statt dessen sind die Regeln 4 und 5 relevant. true wird vor dem Vergleich in eine Zahl, also 1 konvertiert, und in a steht die Zeichenkette "b", deren Konvertierung in eine Zahl NaN ergibt. Der Vergleich NaN == 1 ergibt false.

Die erste Meldung erscheint, weil hier die Zeichenkette "b" nicht in einem Vergleichsausdruck steht, sondern als ein truthy Wert an einer Stelle erscheint, wo ein boolescher Wert erwartet wird.

Typgenaue Vergleiche

Um bei Vergleichen auf einfache Art auch den Datentyp berücksichtigen zu können, wurden mit der JavaScript-Version 1.2 zwei typgenaue Vergleichsoperatoren eingeführt:

Operator	Bedeutung	Ergebnis der Operation
===	istgleich	true, wenn beide Werte gleich und außerdem gleichen Typs sind, sonst false.
!==	ungleich	true, wenn die Werte ungleich oder nicht gleichen Typs sind, sonst false.

• Zuweisungsoperator
• Sprachelemente (Übersicht)
• Rechenoperatoren