Strikte Ungleichheit (!==) — Operator · JavaScript-Referenz

Signatur

x !== y

Beschreibung

Der Operator !== ist das logische Gegenstück zur strikten Gleichheit ===: x !== y ergibt immer dasselbe wie !(x === y). Anders als die lose Ungleichheit != wandelt er die Operanden nicht in einen gemeinsamen Typ um. Haben die Werte unterschiedliche Typen, gelten sie immer als ungleich, also ist 1 !== "1" gleich true.

Der Vergleich folgt dem Algorithmus IsStrictlyEqual:

Unterschiedliche Typen → ungleich.
Primitive Werte gleichen Typs (String, Number, BigInt, Boolean, Symbol, undefined, null) werden nach ihrem Wert verglichen.
Objekte (dazu gehören auch Arrays, Funktionen und Datumsobjekte) werden nach ihrer Referenz verglichen. Zwei verschiedene Objekte mit gleichem Inhalt sind also ungleich.
Sonderfälle: NaN !== NaN ergibt true, und +0 !== -0 ergibt false.

In modernem Code ist !== die übliche Wahl für Ungleichheitsprüfungen. Das Verhalten ist vorhersehbar, erspart schwer erkennbare Fehler durch Typumwandlung und wird von Lintern wie ESLint (Regel eqeqeq) empfohlen.

Parameter

Name	Typ	Default	Beschreibung
$x Pflicht	any		Linker Operand, ein beliebiger Wert oder Ausdruck.
$y Pflicht	any		Rechter Operand, ein beliebiger Wert oder Ausdruck. Er wird nicht in den Typ von `x` umgewandelt.

Rückgabewert

Typ

boolean

Beschreibung

true, wenn die Operanden unterschiedliche Typen oder unterschiedliche Werte bzw. Referenzen haben, sonst false.

Beispiele

Grundlegende Vergleiche ohne Typumwandlung

console.log(3 !== 3);          // gleicher Typ, gleicher Wert
console.log(3 !== "3");        // Number vs. String
console.log(0 !== false);      // Number vs. Boolean
console.log(null !== undefined);
console.log("abc" !== "ABC");  // Groß-/Kleinschreibung zählt

// Zum Vergleich: lose Ungleichheit wandelt um
console.log(3 != "3");

false true true true true false

Objekte werden nach Referenz verglichen

const a = { id: 1 };
const b = { id: 1 };
const c = a;

console.log(a !== b); // verschiedene Objekte
console.log(a !== c); // dieselbe Referenz
console.log([] !== []);

true false true

Praxis: Formularwert nur bei Änderung speichern

const saveIfChanged = async (field, newValue, oldValue) => {
  if (newValue !== oldValue) {
    await fetch(`/api/profile/${field}`, {
      method: "PATCH",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ value: newValue })
    });
    console.log(`${field} gespeichert`);
  } else {
    console.log(`${field} unverändert`);
  }
};

// Input-Werte sind immer Strings – daher gezielt umwandeln
const ageInput = "42";
saveIfChanged("age", Number(ageInput), 42);

age unverändert

Sonderfälle NaN und ±0

console.log(NaN !== NaN);          // true – NaN ist zu nichts gleich
console.log(+0 !== -0);            // false
console.log(!Object.is(+0, -0));   // true – Object.is unterscheidet ±0

const value = Number("abc");
// Falsch: value !== NaN ist immer true
console.log(value !== NaN);
// Richtig:
console.log(Number.isNaN(value));

true false true true true

// Wichtig · Fallstricke

NaN-Falle: x !== NaN ergibt immer true, auch wenn x selbst NaN ist. Zur Prüfung Number.isNaN(x) verwenden.
Vorzeichenbehaftete Null: +0 !== -0 ergibt false. Wer die beiden unterscheiden muss, nimmt !Object.is(a, b).
Objekte und Arrays: Es wird nur die Referenz verglichen, nicht der Inhalt. Für einen inhaltlichen Vergleich braucht man einen eigenen Tiefenvergleich (zum Beispiel über die Schlüssel) oder eine Bibliothek.
Wrapper-Objekte: new String(\"a\") !== \"a\" ergibt true, weil Objekt und Primitiv unterschiedliche Typen haben. Wrapper-Konstruktoren sollte man daher meiden.
Nutzereingaben: Werte aus input.value, URLSearchParams oder localStorage sind immer Strings. Vor dem Vergleich mit Zahlen gezielt umwandeln, etwa mit Number().
Prüfung auf null und undefined zusammen: Hier ist x != null die einzige verbreitete Ausnahme, in der die lose Form bewusst eingesetzt wird. Alternativ gibt es ?? und ?..

Siehe auch

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