Beim Vergleich von Zahlen funktionieren diese Operatoren wie erwartet:
3 < 4 // true
3 >= 4 // false
Jeder Vergleich mit NaN ergibt false:
NaN < 4 // false
NaN >= 4 // false
NaN <= NaN // false
Mit denselben Operatoren lassen sich auch Strings vergleichen, wobei die alphabetische Reihenfolge beachtet wird:
'Hello' < 'Goodbye' // false: H steht hinter G
'Hello' < 'Hi' // true: e steht vor i
Achten Sie beim Vergleich von Werten mit <, <=, > und >= darauf, dass entweder beide Operanden Zahlen oder beide Operanden Strings sind. Wandeln Sie die Operanden ggf. ausdrücklich um. Anderenfalls konvertiert JavaScript die Operanden. Das führt manchmal zu unerwünschten Ergebnissen, wie Sie im nächsten Abschnitt sehen werden.
Zum Test auf Gleichheit verwenden Sie die folgenden Operatoren:
=== strikt gleich
!== nichtstrikt gleich
Diese strikten Gleichheitsoperatoren sind unproblematisch. Operanden unterschiedlicher Typen sind niemals exakt gleich. Die Werte undefined und null sind nur zu sich selbst strikt gleich. Zahlen, boolesche Werte und Strings sind nur dann strikt gleich, wenn ihre Werte gleich sind.
'42' === 42 // false: unterschiedliche Typen
undefined === null // false
'42' === '4' + 2 // tru: derselbe String-Wert, nämlich '42'
Daneben gibt es die schwachen Gleichheitsoperatoren == und !=, die auch Werte unterschiedlicher Typen vergleichen. Das ist im Allgemeinen nicht nützlich. Genaueres dazu erfahren Sie im nächsten Abschnitt.
Vorsicht
Es ist nicht möglich, x === NaN zu verwenden, um zu prüfen, ob x gleich NaN ist. Keine zwei NaN-Werte werden als gleich angesehen. Rufen Sie stattdessen Number.isNaN(x) auf.
Hinweis
Object.is(x, y) ist fast identisch mit x === y. Die einzigen Ausnahmen bestehen darin, dass Object.is(+0, -0) zu false ausgewertet wird und Object.is(NaN, NaN) zu true.
Wie in Java und Python bedeutet die Gleichheit von Objekten (einschließlich Arrays), dass die beiden Operanden auf dasselbe Objekt verweisen. Verweise auf verschiedene Objekte sind niemals gleich, selbst wenn die beiden Objekte den gleichen Inhalt haben.
let harry = { name: 'Harry Smith', age: 42 }
let harry2 = harry
harry === harry2 // true: zwei Verweise auf dasselbe Objekt
let harry3 = { name: 'Harry Smith', age: 42 }
harry === harry3 // false: verschiedene Objekte
2.6Vergleiche unterschiedlicher Typen
Dies ist ein weiterer »Verrückter Hutmacher«-Abschnitt, der einen verwirrenden Aspekt von JavaScript ausführlicher beschreibt. Sie können ihn getrost überspringen, wenn Sie die goldene Regel Nr. 3 befolgen und Vergleiche unterschiedlicher Typen sowie vor allem die schwachen Gleichheitsoperatoren == und != vermeiden.
Als Erstes sehen wir uns hier Vergleiche unterschiedlicher Typen mit den Operatoren <, <=, > und >= an.
Wenn ein Operand eine Zahl ist, wird der andere ebenfalls in eine Zahl umgewandelt. Nehmen wir an, der zweite Operator ist ein String. In diesem Fall wird er in den zugehörigen numerischen Wert umgewandelt, wenn er die String-Darstellung einer Zahl ist, in 0, wenn der String leer ist, und in allen anderen Fällen in NaN. Jeder Vergleich mit NaN ergibt false, selbst NaN <= NaN.
'42' < 5 // false: '42' wird in die Zahl 42 umgewandelt
'' < 5 // true: '' wird in die Zahl 0 umgewandelt
'Hello' <= 5 // false: 'Hello' wird in NaN umgewandelt
5 <= 'Hello' // false: 'Hello' wird in NaN umgewandelt
Ist der andere Operand ein Array, sind folgende Fälle möglich:
[4] < 5 // true: [4] wird in die Zahl 4 umgewandelt
[] < 5 // true: [] wird in die Zahl 0 umgewandelt
[3, 4] < 5 // false: [3, 4] wird in NaN umgewandelt
Ist keiner der Operanden eine Zahl, werden beide in Strings umgewandelt. Vergleiche dieser Art liefern jedoch nur äußerst selten sinnvolle Ergebnisse:
[1, 2, 3] < {} // true: [1, 2, 3] wird in '1,2,3' umgewandelt und{} in
// '[object Object]'
Als Nächstes sehen wir uns einen schwachen Gleichheitstest wie x == y genauer an. Dabei geschieht Folgendes:
Sind beide Operanden vom selben Typ, werden sie strikt verglichen.
Die Werte undefined und null sind nur zu sich selbst und zueinander schwach gleich, aber zu keinem anderen Wert.
Ist einer der Operanden eine Zahl und der andere ein String, wird der String in eine Zahl umgewandelt und diese mit der anderen strikt verglichen.
Ist einer der Operanden ein boolescher Wert, werden beide in Zahlen umgewandelt und strikt verglichen.
Ist einer der Operanden ein Objekt und der andere nicht, wird das Objekt in einen primitiven Typ umgewandelt (siehe Kapitel 8) und dann schwach verglichen.
Betrachten Sie dazu die folgenden Beispiele:
'' == 0 // true: '' wird in 0 umgewandelt
'0' == 0 // true: '0' wird in 0 umgewandelt
'0' == false // true: Beide Operanden werden in 0 umgewandelt
undefined == false // false: undefined ist nur zu null und sich selbst gleich
Schauen wir uns noch einmal die beiden Strings '' und '0' an. Sie sind beide gleich 0, aber nicht zueinander gleich:
'' == '0' // false: Beide Operanden sind Strings, daher keine Umwandlung
Wie Sie sehen, sind die Regeln für schwache Vergleiche nicht sehr nützlich und können leicht zu schwer aufzuspürenden Fehlern fühlen. Vermeiden Sie diesen Sumpf, indem Sie nur die strikten Gleichheitsoperatoren === und !== verwenden.
Hinweis
Der schwache Vergleich x == null prüft in Wirklichkeit,