Ungleichheit (!=) — Operator · JavaScript-Referenz

Signatur

x != y

Beschreibung

Der Ungleichheitsoperator (!=) vergleicht zwei Werte und gibt true zurück, wenn sie nicht gleich sind, andernfalls false. Er ist das logische Gegenstück zum Gleichheitsoperator (==) und arbeitet mit abstrakter Gleichheit (Abstract Equality Comparison): Vor dem eigentlichen Vergleich werden unterschiedliche Typen automatisch konvertiert (Type Coercion), sodass z. B. "5" != 5 den Wert false ergibt.

Die Typ-Konvertierungsregeln folgen dem ECMAScript-Standard und können zu überraschenden Ergebnissen führen. So gilt etwa null != undefined → false, obwohl beides unterschiedliche Typen sind. Objekte werden bei einem Vergleich mit primitiven Werten zunächst in Primitive umgewandelt (via valueOf() bzw. toString()).

In der modernen JavaScript-Entwicklung wird empfohlen, stattdessen den strikten Ungleichheitsoperator !== zu verwenden, da dieser keine implizite Typkonvertierung durchführt und daher leichter vorhersagbar ist. != sollte nur dann bewusst eingesetzt werden, wenn man sich die automatische Konvertierung zunutze machen möchte — z. B. um gleichzeitig auf null und undefined zu prüfen (wert != null).

Der Operator ist binär und erwartet einen linken sowie einen rechten Operanden. Der Rückgabewert ist immer ein boolescher Wert (boolean).

Parameter

Name	Typ	Default	Beschreibung
$x Pflicht	any	—	Der linke Operand. Kann ein beliebiger JavaScript-Wert sein (Zahl, Zeichenkette, Objekt, `null`, `undefined` usw.).
$y Pflicht	any	—	Der rechte Operand. Kann ein beliebiger JavaScript-Wert sein. Vor dem Vergleich wird ggf. eine implizite Typkonvertierung durchgeführt.

Rückgabewert

Typ

boolean

Beschreibung

true, wenn die beiden Operanden nach abstrakter Gleichheit nicht gleich sind; false, wenn sie (nach etwaiger Typkonvertierung) als gleich gelten.

Beispiele

Grundlegende Vergleiche mit gleichen Typen

console.log(5 != 5);       // false — gleiche Zahl
console.log(5 != 6);       // true  — unterschiedliche Zahlen
console.log("a" != "a");  // false — gleiche Zeichenkette
console.log("a" != "b");  // true  — unterschiedliche Zeichenketten
console.log(true != true); // false
console.log(true != false);// true

false true false true false true

Implizite Typkonvertierung (Type Coercion)

console.log(5 != "5");       // false — Zeichenkette wird zu Zahl konvertiert
console.log(0 != false);     // false — false wird zu 0 konvertiert
console.log(0 != "");        // false — leerer String wird zu 0 konvertiert
console.log(null != undefined); // false — Sonderregel: beide gelten als gleich
console.log(null != 0);      // true  — null wird NICHT zu 0 konvertiert
console.log(NaN != NaN);     // true  — NaN ist niemals gleich NaN

false false false false true true

Praxisbeispiel: null-und-undefined-Check mit !=

// Klassischer Einsatz von != um gleichzeitig null UND undefined auszuschließen
const prüfeWert = (wert) => {
  if (wert != null) {
    // Trifft zu für alles außer null und undefined
    console.log(`Wert vorhanden: ${wert}`);
  } else {
    console.log("Wert ist null oder undefined");
  }
};

prüfeWert(42);        // Wert vorhanden: 42
prüfeWert("Hallo");   // Wert vorhanden: Hallo
prüfeWert(null);      // Wert ist null oder undefined
prüfeWert(undefined); // Wert ist null oder undefined

Wert vorhanden: 42 Wert vorhanden: Hallo Wert ist null oder undefined Wert ist null oder undefined

Vergleich von Objekten (Referenzvergleich)

const obj1 = { name: "Alice" };
const obj2 = { name: "Alice" };
const obj3 = obj1;

console.log(obj1 != obj2); // true  — unterschiedliche Referenzen
console.log(obj1 != obj3); // false — gleiche Referenz

true false

// Wichtig · Fallstricke

Empfehlung: Nutze in modernem JavaScript bevorzugt den strikten Ungleichheitsoperator !==, der keine Typkonvertierung vornimmt und damit weniger fehleranfällig ist. != sollte nur dann bewusst eingesetzt werden, wenn die Typkonvertierung beabsichtigt ist.

NaN-Falle: NaN != NaN ergibt immer true. Um auf NaN zu prüfen, verwende Number.isNaN() oder isNaN().
null vs. undefined: null != undefined ergibt false — dies ist eine bewusste Ausnahme im ECMAScript-Standard und der einzige empfohlene Anwendungsfall für != gegenüber !==.
Objekte: Beim Vergleich zweier Objekte wird immer die Referenzgleichheit geprüft, nicht der Inhalt. Zwei strukturell identische Objekte sind ungleich (!= → true), solange es sich um verschiedene Instanzen handelt.
Linter-Warnung: ESLint und viele andere Linter melden bei Verwendung von != (statt !==) standardmäßig eine Warnung (Regel eqeqeq).

Siehe auch

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