Strikte Gleichheit (===) — Operator · JavaScript-Referenz

Signatur

x === y

Beschreibung

Der strikte Gleichheitsoperator === (auch Triple-Equals genannt) vergleicht zwei Operanden auf Gleichheit, ohne dabei eine Typkonvertierung vorzunehmen. Haben die beiden Werte unterschiedliche Typen, ist das Ergebnis immer false. Sind die Typen gleich, werden die Werte direkt verglichen.

Die Vergleichsregeln im Überblick:

Primitive Typen (number, string, boolean, bigint, symbol): Wert-für-Wert-Vergleich — gleiche Typen und gleiche Werte ergeben true.
Sonderfall NaN: NaN === NaN ergibt false. Stattdessen Number.isNaN() verwenden.
Sonderfall ±0: +0 === -0 ergibt true. Zur Unterscheidung Object.is() verwenden.
Objekte, Arrays und Funktionen: Es findet ein Referenzvergleich statt — zwei Objekte sind nur dann strikt gleich, wenn sie auf dasselbe Objekt im Speicher zeigen.
null === null ist true, undefined === undefined ist true, aber null === undefined ist false.

Im Unterschied zum losen Gleichheitsoperator == führt === keine implizite Typumwandlung durch. Dadurch entstehen keine unerwarteten Nebeneffekte durch den abstrakten Gleichheitsalgorithmus (Abstract Equality Comparison). In der modernen JavaScript-Entwicklung wird deshalb grundsätzlich === gegenüber == bevorzugt.

Intern verwendet === den sogenannten Strict Equality Comparison-Algorithmus der ECMAScript-Spezifikation, der sich von Object.is() nur in den Sonderfällen NaN und ±0 unterscheidet.

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

Typ

boolean

Beschreibung

true, wenn beide Operanden denselben Typ und denselben Wert haben (bzw. dieselbe Referenz bei Objekten); andernfalls false.

Beispiele

Grundlegende Vergleiche mit primitiven Typen

// Zahlen
console.log(42 === 42);        // true
console.log(42 === '42');      // false — unterschiedliche Typen
console.log(0 === false);      // false — unterschiedliche Typen

// Strings
console.log('hallo' === 'hallo');  // true
console.log('hallo' === 'Hallo'); // false — Groß-/Kleinschreibung beachten

// Boolean
console.log(true === true);    // true
console.log(true === 1);       // false — unterschiedliche Typen

// null & undefined
console.log(null === null);        // true
console.log(undefined === undefined); // true
console.log(null === undefined);   // false

true false false true false true false true true false

Sonderfälle: NaN und ±0

// NaN ist nie strikt gleich sich selbst
console.log(NaN === NaN);    // false
// Korrekte Prüfung mit Number.isNaN
console.log(Number.isNaN(NaN)); // true

// +0 und -0 gelten als strikt gleich
console.log(+0 === -0);      // true
// Unterscheidung mit Object.is
console.log(Object.is(+0, -0)); // false

false true true false

Referenzvergleich bei Objekten und Arrays

const a = { name: 'Alice' };
const b = { name: 'Alice' };
const c = a;

console.log(a === b); // false — verschiedene Objekte im Speicher
console.log(a === c); // true  — gleiche Referenz

const arr1 = [1, 2, 3];
const arr2 = [1, 2, 3];
console.log(arr1 === arr2); // false — verschiedene Arrays

false true false

Praxiseinsatz: Typensichere Bedingungsprüfung

const getUserRole = (role) => {
  if (role === 'admin') {
    return 'Zugriff auf alle Bereiche gewährt.';
  } else if (role === 'editor') {
    return 'Zugriff auf den Editor gewährt.';
  }
  return 'Kein Zugriff.';
};

console.log(getUserRole('admin'));  // Zugriff auf alle Bereiche gewährt.
console.log(getUserRole('editor')); // Zugriff auf den Editor gewährt.
console.log(getUserRole(0));        // Kein Zugriff. (0 == 'admin' wäre false, sicher)

Zugriff auf alle Bereiche gewährt. Zugriff auf den Editor gewährt. Kein Zugriff.

// Wichtig · Fallstricke

Bevorzuge immer === gegenüber ==: Der lose Gleichheitsoperator == führt implizite Typkonvertierungen durch, die zu schwer nachvollziehbaren Ergebnissen führen können (z. B. '' == false // true). Viele Style-Guides (ESLint-Regel eqeqeq) und Linter erzwingen daher die Verwendung von ===.

NaN-Falle: Da NaN === NaN immer false ergibt, darf === nicht zur NaN-Erkennung genutzt werden. Verwende stattdessen Number.isNaN(wert).

Objektvergleich: Sollen zwei Objekte inhaltlich verglichen werden, muss eine manuelle Tiefenprüfung (Deep-Equal) implementiert oder eine Bibliothek (z. B. Lodash _.isEqual) genutzt werden — === vergleicht bei Objekten ausschließlich Referenzen.

Browser-Kompatibilität: === ist seit den Anfängen von JavaScript in allen Browsern und JavaScript-Laufzeitumgebungen verfügbar. Es gibt keine Kompatibilitätsprobleme.

Siehe auch

== (Lose Gleichheit) !== (Strikte Ungleichheit) Object.is() Number.isNaN() != (Lose Ungleichheit)