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:
true oder beide false sind.true, wenn die Operanden auf das gleiche Objekt zeigen.Null und undefined sind immer strikt gleich zu sich selbst und abstrakt gleich zueinander.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.
x == y
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
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
1 != 2 // true 1 != "1" // false 1 != '1' // false 1 != true // false 0 != false // false
Der Identitätsoperator gibt true zurück, wenn die Operanden strikt gleich sind (siehe oben) ohne eine Typkonvertierung
x === y
3 === 3 // true
3 === '3' // false
var object1 = {'key': 'value'}, object2 = {'key': 'value'}
object1 === object2 // false
Der strikte Ungleichheitsoperator gibt true zurück, wenn die Operanden nicht vom gleichen Typ sind bzw. ungleich sind.
x !== y
3 !== '3' // true 4 !== 3 // true
Jeder dieser Operatoren wird die valueOf() Funktion aufrufen, bevor ein Vergleich durchgeführt wird.
Der Größer-als-Operator gibt true zurück, wenn der linke Operand größer als der rechte Operand ist.
x > y
4 > 3 // true
Der Größer-oder-gleich-Operator gibt true zurück, wenn der linke Operand größer als oder gleich dem rechten Operanden ist.
x >= y
4 >= 3 // true 3 >= 3 // true
Der Kleiner-als-Operator gibt true zurück, wenn der linke Operand kleiner als der rechte Operand ist.
x < y
3 < 4 // true
Der Kleiner-oder-gleich-Operator gibt true zurück, wenn der linke Operand kleiner oder gleich dem rechten Operanden ist.
x <= y
3 <= 4 // true
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 {{jsxref("String")}}, {{jsxref("Number")}}, {{jsxref("Boolean")}} und {{jsxref("Object")}} und führt den Vergleich dann aus:
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.true ist und zur +0 wenn false.String oder Number) umzuwandeln, indem sie die valueOf und toString Methoden der Objekte benutzen. Kann ein Objekt nicht umgewandelt werden, wird ein Laufzeitfehler erzeugt.// 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'
| Spezifikation | Status | Kommentar |
|---|---|---|
| {{SpecName('ES1')}} | {{Spec2('ES1')}} | Initial Definition. Implementiert in JavaScript 1.0 |
| {{SpecName('ES3')}} | {{Spec2('ES3')}} | Fügt === und !== Operatoren hinzu. Implementiert in JavaScript 1.3 |
| {{SpecName('ES5.1', '#sec-11.8')}} | {{Spec2('ES5.1')}} | In verschiedenen Kapiteln der Spezifikation definiert: Relational Operators, Equality Operators |
| {{SpecName('ES6', '#sec-relational-operators')}} | {{Spec2('ES6')}} | In verschiedenen Kapiteln der Spezifikation definiert: Relational Operators, Equality Operators |
| {{SpecName('ESDraft', '#sec-relational-operators')}} | {{Spec2('ESDraft')}} | In verschiedenen Kapiteln der Spezifikation definiert: Relational Operators, Equality Operators |
{{Compat("javascript.operators.comparison")}}