JavaScript Gleichheit: == vs === und Object.is erklärt

Zwei Wege, "Sind die gleich?" zu fragen

JavaScript bietet zwei Gleichheitsoperatoren: === (strikt) und == (locker). Sie sehen fast gleich aus. Sie verhalten sich aber völlig unterschiedlich.

=== prüft, ob beide Operanden denselben Typ und denselben Wert haben. == konvertiert die Operanden zuerst in einen gemeinsamen Typ und vergleicht sie dann. Genau diese Konvertierung — die sogenannte Typumwandlung (type coercion) — ist der Grund für den zweifelhaften Ruf der Gleichheit in JavaScript.

Die Kurzfassung: Nimm standardmäßig ===. Die lange Version lohnt sich trotzdem einmal zu lesen, damit du weißt, worauf du da eigentlich verzichtest.

Strikte Gleichheit: Das willst du vermutlich

Der strikte Gleichheitsoperator === liefert nur dann true, wenn Typ und Wert auf beiden Seiten übereinstimmen. Keine Umwandlung, keine Überraschungen:

Stimmen die Typen nicht überein, ist das Ergebnis sofort false. Stimmen sie überein, vergleicht JavaScript die Werte. Bei Primitiven ist das ein Wertvergleich, bei Objekten ein Referenzvergleich (dazu gleich mehr).

!== ist der strikte Ungleichheitsoperator und funktioniert nach denselben Regeln, nur umgekehrt.

Lockere Gleichheit: Typumwandlung im Hintergrund

Bei == dürfen beide Seiten unterschiedliche Typen haben. Vor dem eigentlichen Vergleich startet JavaScript einen Coercion-Tanz, um die Typen anzugleichen:

Die genauen Regeln stehen in der Spec und sind gar nicht mal so schlimm – sie sich aber mitten im Debugging zu merken, ist eine andere Geschichte. Dass "0" == false tatsächlich true ergibt, erwischt selbst erfahrene Entwickler. Genauso wie [] == false (ebenfalls true, weil das Array zu "" umgewandelt wird und das wiederum zu 0).

Genau deshalb empfehlen die meisten Styleguides – und auch die ESLint-Regel eqeqeq – standardmäßig === zu verwenden. Du tippst ein Zeichen mehr und bekommst dafür Regeln, die du dir wirklich merken kannst.

Das eine sinnvolle Muster mit ==

Es gibt genau ein Idiom mit lockerer Gleichheit, das man kennen sollte: x == null liefert true, wenn x entweder null oder undefined ist – und false in allen anderen Fällen.

Das strikte Äquivalent wäre x === null || x === undefined — funktioniert, liest sich aber deutlich lauter. Viele Codebases erlauben deshalb == null als einzige gesegnete Ausnahme. Entscheide dich für eine Regel und zieh sie konsequent durch.

Objekte vergleichen: Referenz statt Inhalt

Bei Objekten, Arrays und Funktionen stellen === und == dieselbe Frage: „Zeigen beide Seiten auf dasselbe Objekt im Speicher?" Und eben nicht: „Haben sie denselben Inhalt?"

Zwei Objektliterale mit exakt gleichem Inhalt bleiben trotzdem zwei verschiedene Objekte. Über diese Falle stolpert wirklich jeder mindestens einmal.

Wenn du Objekte in JavaScript inhaltlich vergleichen willst, schreibst du dir entweder eine eigene Hilfsfunktion, greifst zu einer Library wie lodash.isequal oder serialisierst einfache Plain Objects mit JSON.stringify:

JSON.stringify funktioniert nur für einfache Daten – Funktionen, undefined und Symbole werden ignoriert, und die Reihenfolge der Schlüssel ist über verschiedene Engines hinweg nicht für jede Form garantiert. Das ist eher ein schneller Check als eine allgemeine Lösung.

NaN ist mit nichts gleich – auch nicht mit sich selbst

NaN ("not a number") ist der Wert, den JavaScript zurückgibt, wenn eine Rechenoperation kein sinnvolles Ergebnis liefert – etwa bei 0/0, Number("abc") oder Math.sqrt(-1). Beide Gleichheitsoperatoren geben false zurück, sobald auch nur eine Seite NaN ist – selbst dann, wenn beide Seiten NaN sind:

Für den Check auf NaN nimmst du Number.isNaN(value). Finger weg vom alten globalen isNaN — das wandelt sein Argument erst um, weshalb isNaN("hello") tatsächlich true liefert. Das will man praktisch nie.

Object.is: fast wie ===, nur mit zwei Korrekturen

Object.is(a, b) verhält sich genauso wie ===, bis auf zwei Sonderfälle:

In den meisten Fällen ist === genau das, was du willst. Zu Object.is greifst du nur dann, wenn du NaN explizit als gleich mit sich selbst behandeln oder +0 von -0 unterscheiden musst — beides kommt selten vor, spielt aber gelegentlich in numerischem Code oder in Framework-Internas eine Rolle (React nutzt Object.is zum Beispiel beim Vergleich von State).

Ungleichheitsoperatoren folgen derselben Logik

!== ist strikt, != ist locker — und es gelten exakt dieselben Empfehlungen:

Standardmäßig !==. Wenn du == null erlaubst, kannst du analog auch != null für den Check „weder null noch undefined" zulassen.

Checkliste zum Vergleichen in JavaScript

Wenn du zwei Werte vergleichen willst, arbeite diese Punkte der Reihe nach ab:

• Primitives vom selben Typ? Nimm ===.
• Auf null oder undefined prüfen? x == null ist okay, wenn dein Styleguide das erlaubt – sonst x === null || x === undefined.
• Auf NaN prüfen? Number.isNaN(x).
• Objekte per Identität vergleichen? === macht genau das.
• Objekte per Inhalt vergleichen? Schreib dir einen Helper, nimm eine Library oder serialisiere. Die eingebauten Operatoren helfen dir hier nicht weiter.

Bleib bei ===, sieh == nur als Spezialwerkzeug für den Fall == null – damit umgehst du die klassischen Stolperfallen rund um den JavaScript-Gleichheitsoperator, die in jeder FAQ auftauchen.

Als Nächstes: Operatoren

Gleichheit ist nur ein kleiner Ausschnitt aus dem Operator-Universum von JavaScript. Im nächsten Kapitel geht es um den Rest – arithmetische, logische und Zuweisungs-Operatoren sowie die Kurzformen, die dir im Alltag ständig begegnen.