Vergleichsoperatoren

JavaScript kennt sowohl den strikten als auch nicht-strikten Vergleich. Ein strikter Vergleich (z.B. ===) ist nur wahr bei Operanden gleichen Typs. Der häufiger verwendete nicht-strikter 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.

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

Merkmale von Vergleichen:

  • Zwei Zeichenketten 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. Positive und negative Nullen sind strikt gleich.
  • 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 als wahr (true), wenn die Operanden auf das gleiche Objekt zeigen.
  • Die Typen Null und undefined sind sich gegenüber strikt gleich und gegenseitig nicht-strikt gleich.

Gleichheitsoperatoren

Gleichheit (==)

Der Gleichheitsoperator vergleicht zwei Operanden. Sind die Operanden nicht gleichen Typs werden sie zuerst umgewandelt. 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

Ungleichheit (!=)

Der Ungleichheitsoperator gibt wahr zurück, wenn die Operanden nicht gleich sind. Wenn die beiden Operanden nicht vom gleichen Typ sind, versucht JavaScript die Operanden in einen passenden Typ für den Vergleich 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 wahr zurück, wenn die Operanden strikt gleich sind (siehe oben). Insbesondere werden die Operanden vor dem Vergleich nicht konvertiert.

Syntax

x === y

Beispiele

3 === 3   // true
3 === '3' // false

Strikte Ungleichheit (!==)

Der strikte Ungleichheitsoperator gibt wahr 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

Operator größer als (>)

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

Syntax

x > y

Beispiele

4 > 3 // true

Operator größer oder gleich (>=)

Der Operator größer-oder-gleich gibt wahr 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

Operator kleiner als (<)

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

Syntax

 x < y

Beispiele

3 < 4 // true

Operator kleiner oder gleich (<=)

Der Kleiner-oder-gleich-Operator gibt wahr 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 Algorithm, 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 Algorithm und sind dafür gedacht, Operanden des gleichen Typs zu vergleichen.  Wenn die Operanden von unterschiedlichen Typen sind, ist das Ergebnis immer unwahr (false); somit ist 5!=='5' wahr.

Strikte Gleichheitsoperatoren sollten verwendet werden, wenn die Operanden sowohl einen bestimmten Typen als auch Wert haben sollen. Ansonsten benutzt man die nicht-strikten 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 die Operanden vom Typ String, Number, Boolean oder Objekt wie folgt:

  • 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 wahr ist und zur +0 wenn unwahr.
  • 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 wahr, wenn beide auf das gleiche Objekt zeigen.
Hinweis: Der Type einer Zeichenkette ist Object und nicht String! Zeichenkettenobjekte werden kaum benutzt, daher sind die folgenden Ergebnisse möglicherweise überraschend:
// true, da beide Zeichenkettenliterale sind (i.e. 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, das Objekt (a) 
// wird vor dem Vergleich zum String 'foo' umgewandelt
a == 'foo' 

Spezifikationen

Spezifikation Status Kommentar
ECMAScript 1st Edition. Standard Initial definition. Implemented in JavaScript 1.0
ECMAScript 3rd Edition. Standard Adds === and !== operators. Implemented in JavaScript 1.3
ECMAScript 5.1 (ECMA-262)
Die Definition von 'Relational Operators' in dieser Spezifikation.

ECMAScript 5.1 (ECMA-262)
Die Definition von 'Equality Operators' in dieser Spezifikation.
Standard  
ECMAScript 2015 (6th Edition, ECMA-262)
Die Definition von 'Relational Operators' in dieser Spezifikation.

ECMAScript 2015 (6th Edition, ECMA-262)
Die Definition von 'Equality Operators' in dieser Spezifikation.
Standard  

Browserkompatibilität

Merkmal Chrome Firefox (Gecko) Internet Explorer Opera Safari
Basic support (Ja) (Ja) (Ja) (Ja) (Ja)
Merkmal Android Chrome for Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
Basic support (Ja) (Ja) (Ja) (Ja) (Ja) (Ja)

Siehe auch

Schlagwörter des Dokuments und Mitwirkende

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