JavaScript kennt sowohl den strikten als auch den Typ konvertierenden Vergleich. Ein strikter Vergleich (z. B. ===) gibt nur true zurück, wenn der gleiche Typ und der gleiche Wert vorhanden sind. Der häufiger verwendete abstrakte Vergleich (z. B. ==) wandelt die Operanden in den gleichen Typen um, bevor sie verglichen werden. Bei relationalen Vergleichsoperatoren (z. B. <=) werden die Operanden vor dem Vergleich zuerst in elementare Datentypen konvertiert und dann in gleiche Typen umgewandelt.

Strings werden entsprechend der lexikographischen Ordnung, basierend auf den Unicode, verglichen.

Merkmale von Vergleichen:

  • Zwei Strings sind strikt gleich, wenn sie die gleiche Abfolge von Zeichen, die gleiche Länge und die gleichen Zeichen in übereinstimmenden Positionen haben.
  • Zwei Zahlen sind strikt gleich, wenn sie numerisch gleich sind (den gleichen Zahlwert haben). NaN ist mit nichts gleich, auch nicht mit sich selbst. +0 und -0 sind strikt gleich zueinander.
  • Zwei Boolesche Operanden sind exakt gleich wenn beide true oder beide false sind.
  • Zwei unterschiedliche Objekte sind niemals gleich, weder in strikten noch nicht-strikten Vergleichen.
  • Ein Ausdruck, der Objekte vergleicht, gilt nur als true, wenn die Operanden auf das gleiche Objekt zeigen.
  • Die Typen Null und undefined sind immer strikt gleich zu sich selbst und abstrakt gleich zueinander.

Gleichheitsoperatoren

Gleichheit (==)

Der Gleichheitsoperator konvertiert die Operanden, wenn sie nicht vom gleichen Typs sind und prüft dann auf strikte Gleichheit. Sind beide Operanden Objekte, vergleicht JavaScript die Referenzen; Referenzen gelten als gleich, wenn sie auf das gleiche Objekt im Speicher zeigen.

Syntax

x == y

Beispiele

1    ==  1     // true
'1'  ==  1     // true
1    == '1'    // true
0    == false  // true
0    == null   // false
var object1 = {'key': 'value'}, object2 = {'key': 'value'}
object1 == object2 // false
0    == undefined  // false
null == undefined  // true

Ungleichheit (!=)

Der Ungleichheitsoperator gibt true zurück, wenn die Operanden nicht gleich sind. Wenn die beiden Operanden nicht vom gleichen Typ sind, versucht JavaScript die Operanden in einen, für den Vergleich passenden Typ, umzuwandeln. Wenn beide Operanden Objekte sind, vergleicht JavaScript die Referenzen; Referenzen sind ungleich, wenn sie auf verschiedene Objekte im Speicher verweisen.

Syntax

x != y

Beispiele

1 !=   2     // true
1 !=  "1"    // false
1 !=  '1'    // false
1 !=  true   // false
0 !=  false  // false

Identität / strikte Gleichheit (===)

Der Identitätsoperator gibt true zurück, wenn die Operanden strikt gleich sind (siehe oben) ohne eine Typkonvertierung

Syntax

x === y

Beispiele

3 === 3   // true
3 === '3' // false
var object1 = {'key': 'value'}, object2 = {'key': 'value'}
object1 === object2 // false

Nicht identisch / Strikte Ungleichheit (!==)

Der strikte Ungleichheitsoperator gibt true zurück, wenn die Operanden nicht vom gleichen Typ sind bzw. ungleich sind.

Syntax

x !== y

Beispiele

3 !== '3' // true
4 !== 3   // true

Relationale Operatoren

Jeder dieser Operatoren wird die valueOf() Funktion aufrufen, bevor ein Vergleich durchgeführt wird.

Größer-als-Operator (>)

Der Größer-als-Operator gibt true zurück, wenn der linke Operand größer als der rechte Operand ist.

Syntax

x > y

Beispiele

4 > 3 // true

Größer-oder-gleich-Operator (>=)

Der Größer-oder-gleich-Operator gibt true zurück, wenn der linke Operand größer als oder gleich dem rechten Operanden ist.

Syntax

 x >= y

Beispiele

4 >= 3 // true
3 >= 3 // true

Kleiner-als-Operator (<)

Der Kleiner-als-Operator gibt true zurück, wenn der linke Operand kleiner als der rechte Operand ist.

Syntax

 x < y

Beispiele

3 < 4 // true

Kleiner-oder-gleich-Operator (<=)

Der Kleiner-oder-gleich-Operator gibt true zurück, wenn der linke Operand kleiner oder gleich dem rechten Operanden ist.

Syntax

 x <= y

Beispiele

3 <= 4 // true

Die Gleichheitsoperatoren anwenden

Die Standard-Gleichheitsoperatoren (== und !=) benutzen den Abstract Equality Comparison Algorithmus, um zwei Operanden zu vergleichen. Sind die Operanden unterschiedlichen Typs, wird vor dem Vergleich zuerst versucht sie in gleiche Typen umzuwandeln; z.B. wird beim Ausdruck 5 == '5'  das Zeichen auf der rechten Seite in eine Zahl konvertiert.

Die strikten Gleichheitsoperatoren (=== und !==) benutzen den Strict Equality Comparison Algorithmus und sind dafür gedacht, Operanden des gleichen Typs zu vergleichen. Wenn die Operanden von unterschiedlichen Typen sind, ist das Ergebnis immer false, wie 5 !== '5'.

Strikte Gleichheitsoperatoren sollten verwendet werden, wenn die Operanden sowohl einen bestimmten Typen als auch Wert haben sollen. Ansonsten benutzt man die abstrakten Gleichheitsoperatoren, die es einem erlauben Operanden unterschiedlicher Typen zu vergleichen.

Wenn beim Vergleich eine Typkonvertierung vorgenommen wird (z.B. beim nicht-strikten Vergleich), konvertiert JavaScript in die Typen String, Number, Boolean und Object und führt den Vergleich dann aus:

  • Wenn eine Zahl und eine Zeichenkette verglichen werden, wird die Zeichenkette zu einem Zahlenwert umgewandelt. JavaScript versucht das numerische Zeichenliteral in einen Wert des Typs Number zu wandeln. Zuerst wird der mathematische Wert des numerischen Zeichenliterals ermittelt. Danach wird der Wert auf den nächsten Wert des Typs Number gerundet.
  • Wenn einer der Operanden ein Boolescher Typ ist, wird der Operand zur 1 konveriert wenn er true ist und zur +0 wenn false.
  • Wenn ein Objekt mit einer Zahl oder einer Zeichenkette verglichen wird,  versucht JavaScript den Defaultwert für das Objekt zurückzugeben. Operatoren versuchen das Objekt in einen elementaren Wert (String oder Number) umzuwandeln, indem sie die valueOf und toString Methoden der Objekte benutzen. Kann ein Objekt nicht umgewandelt werden, wird ein Laufzeitfehler erzeugt.
  • Ein Objekt wird nur dann in einen elementaren Datentypen umgewandelt, wenn sein Vergleichsoperand ein elementarer Datentyp ist. Sind beide Operanden Objekte, werden sie als Objekte verglichen und der Gleichheitstest liefert nur dann true, wenn beide auf das gleiche Objekt zeigen.
Hinweis: String Objekte sind com Typ Objekte, nicht String! String Objekte werden selten eingesetzt, so dass das folgende Ergebnis überraschend sein kann:
// true, da beide Operanden vom Typ String sind (string primitives)
'foo' === 'foo'

var a = new String('foo');
var b = new String('foo');

// false, da a und b auf verschiedene Objekte zeigen 
a == b 

// false, da a und b auf verschiedene Objekte zeigen
a === b 

// true, da a und 'foo' verschiedene Typen sind und das Objekt (a) 
// vor dem Vergleich zum String 'foo' umgewandelt wird
a == 'foo' 

Spezifikationen

Spezifikation Status Kommentar
ECMAScript 1st Edition (ECMA-262) Standard Initial Definition. Implementiert in JavaScript 1.0
ECMAScript 3rd Edition (ECMA-262) Standard Fügt === und !== Operatoren hinzu. Implementiert in JavaScript 1.3
ECMAScript 5.1 (ECMA-262) Standard In verschiedenen Kapiteln der Spezifikation definiert: Relational Operators, Equality Operators
ECMAScript 2015 (6th Edition, ECMA-262) Standard In verschiedenen Kapiteln der Spezifikation definiert: Relational Operators, Equality Operators
ECMAScript Latest Draft (ECMA-262) Entwurf In verschiedenen Kapiteln der Spezifikation definiert: Relational Operators, Equality Operators

Browserkompatibilität

FeatureChromeEdgeFirefoxInternet ExplorerOperaSafari
Equality (a == b) Ja Ja1 Ja Ja Ja
Inequality (a != b) Ja Ja1 Ja Ja Ja
Identity (a === b) Ja Ja1 Ja Ja Ja
Non-identity (a !== b) Ja Ja1 Ja Ja Ja
Greater than (a > b) Ja Ja1 Ja Ja Ja
Greater than or equal (a >= b) Ja Ja1 Ja Ja Ja
Less than (a < b) Ja Ja1 Ja Ja Ja
Less than or equal (a <= b) Ja Ja1 Ja Ja Ja
FeatureAndroid webviewChrome for AndroidEdge mobileFirefox for AndroidOpera AndroidiOS SafariSamsung Internet
Equality (a == b) Ja Ja Ja4 Ja Ja Ja
Inequality (a != b) Ja Ja Ja4 Ja Ja Ja
Identity (a === b) Ja Ja Ja4 Ja Ja Ja
Non-identity (a !== b) Ja Ja Ja4 Ja Ja Ja
Greater than (a > b) Ja Ja Ja4 Ja Ja Ja
Greater than or equal (a >= b) Ja Ja Ja4 Ja Ja Ja
Less than (a < b) Ja Ja Ja4 Ja Ja Ja
Less than or equal (a <= b) Ja Ja Ja4 Ja Ja Ja

Siehe auch

Schlagwörter des Dokuments und Mitwirkende

Schlagwörter: 
Mitwirkende an dieser Seite: christophfriedrich, schlagi123, Elyasin, loki
Zuletzt aktualisiert von: christophfriedrich,