Signatur
Beschreibung
Der Gleichheitsoperator == vergleicht zwei Werte auf Gleichheit. Im Gegensatz zum strikten Gleichheitsoperator === führt == eine abstrakte Gleichheitsprüfung durch, die bei unterschiedlichen Datentypen eine automatische Typkonvertierung (Type Coercion) vornimmt, bevor die Werte verglichen werden. Das Ergebnis ist immer ein boolescher Wert (true oder false).
Die Regeln der Typkonvertierung folgen dem ECMAScript-Standard und können auf den ersten Blick überraschend wirken. Zum Beispiel gilt 0 == false als true, weil false zu 0 umgewandelt wird. Ebenso ist "" == 0 wahr, weil der leere String zu 0 konvertiert wird. null und undefined sind nur untereinander gleich (null == undefined → true), aber niemals gleich anderen Werten.
Wann sollte man == verwenden? In der modernen JavaScript-Entwicklung wird generell empfohlen, stets === (strikter Vergleich) zu bevorzugen, um unerwartete Ergebnisse durch implizite Konvertierungen zu vermeiden. Der ==-Operator kann jedoch gezielt eingesetzt werden, wenn man bewusst auf null-oder-undefined-Prüfungen verzichten und beide Fälle gleichzeitig abdecken möchte (x == null).
- Beide Operanden vom gleichen Typ: direkter Wertvergleich (wie
===). null == undefinedisttrue; alle anderen Kombinationen mitnull/undefinedergebenfalse.- Zahl und String: String wird zur Zahl konvertiert.
- Boolean-Operand: wird zunächst zu einer Zahl konvertiert (
true→1,false→0). - Objekt vs. Primitiv:
valueOf()odertoString()des Objekts wird aufgerufen.
Parameter
| Name | Typ | Default | Beschreibung |
|---|---|---|---|
| $x Pflicht | any | — | Der linke Operand — ein beliebiger JavaScript-Wert. |
| $y Pflicht | any | — | Der rechte Operand — ein beliebiger JavaScript-Wert. |
Rückgabewert
true, wenn die beiden Operanden nach optionaler Typkonvertierung als gleich gelten; andernfalls false.Beispiele
Grundlegende Vergleiche mit gleichen Typen
console.log(42 == 42); // true
console.log("hallo" == "hallo"); // true
console.log(true == true); // true
console.log(null == null); // true
console.log(undefined == undefined); // trueTypkonvertierung in Aktion
console.log(0 == false); // true — false wird zu 0
console.log("" == false); // true — beide werden zu 0
console.log("42" == 42); // true — String wird zu Zahl
console.log(null == undefined); // true — Sonderregel
console.log(null == 0); // false — null ist nur == undefined
console.log([] == false); // true — [] -> "" -> 0, false -> 0Gezielter null-oder-undefined-Check mit ==
// Praxistipp: x == null prüft sowohl null als auch undefined
const prüfeWert = (x) => {
if (x == null) {
console.log("Wert ist null oder undefined");
} else {
console.log(`Wert vorhanden: ${x}`);
}
};
prüfeWert(null); // Wert ist null oder undefined
prüfeWert(undefined); // Wert ist null oder undefined
prüfeWert(0); // Wert vorhanden: 0
prüfeWert(""); // Wert vorhanden:Vergleich mit striktem Operator ===
// Unterschied zwischen == und ===
console.log("1" == 1); // true — Typkonvertierung
console.log("1" === 1); // false — kein gleicher Typ
console.log(false == 0); // true
console.log(false === 0); // false
console.log(null == undefined); // true
console.log(null === undefined); // false// Wichtig · Fallstricke
Empfehlung: In den meisten Situationen sollte der strikte Gleichheitsoperator === bevorzugt werden, da er keine implizite Typkonvertierung durchführt und damit zu vorhersehbarerem Code führt. Viele Linting-Tools (z. B. ESLint mit der Regel eqeqeq) warnen vor der Verwendung von ==.
Ausnahme: x == null ist ein idiomatischer und akzeptierter Muster in JavaScript, um gleichzeitig auf null und undefined zu prüfen, ohne typeof zu benötigen.
NaN-Sonderfall: NaN == NaN ergibt false — NaN ist niemals gleich sich selbst. Verwende stattdessen Number.isNaN() zur Prüfung.
Objekte: Zwei Objekte (inkl. Arrays) sind nur dann gleich, wenn sie auf dasselbe Objekt im Speicher referenzieren — auch bei == findet keine strukturelle Gleichheitsprüfung statt: [] == [] ergibt false.