NaN — Eigenschaft · JavaScript-Referenz

Signatur

NaN

Beschreibung

NaN (kurz für Not-a-Number) ist eine globale, schreibgeschützte Eigenschaft, die den gleichnamigen IEEE-754-Gleitkomma-Sonderwert enthält. Sie tritt auf, wenn eine mathematische Operation kein sinnvolles numerisches Ergebnis liefern kann — etwa beim Versuch, eine nicht-numerische Zeichenkette in eine Zahl umzuwandeln (Number("abc")), bei Operationen wie 0 / 0 oder Math.sqrt(-1), oder wenn parseInt / parseFloat mit unzulässigen Eingaben aufgerufen werden.

Die wichtigste Besonderheit von NaN ist, dass er mit keinem anderen Wert gleich ist — auch nicht mit sich selbst. Der Vergleich NaN === NaN ergibt stets false. Um zu prüfen, ob ein Wert NaN ist, muss daher Number.isNaN() (empfohlen) oder die globale Funktion isNaN() verwendet werden.

Wann verwenden? NaN selbst wird selten aktiv gesetzt; man begegnet ihm vor allem als unerwartetes Ergebnis fehlgeschlagener Zahlenoperationen. In der eigenen Code-Logik prüft man typischerweise mit Number.isNaN(), ob eine Berechnung fehlgeschlagen ist, bevor man das Ergebnis weiterverwendet.

typeof NaN === "number" — obwohl NaN „keine Zahl" bedeutet, ist sein Typ laut JavaScript "number".
NaN ist identisch mit Number.NaN.
Arithmetische Operationen mit NaN als Operand liefern stets wieder NaN.

Rückgabewert

Typ

number

Beschreibung

Der IEEE-754-Sonderwert NaN (Not-a-Number) vom Typ number.

Beispiele

Häufige Quellen von NaN

console.log(Number("abc"));       // NaN
console.log(0 / 0);               // NaN
console.log(Math.sqrt(-1));       // NaN
console.log(parseInt("xyz"));     // NaN
console.log(undefined + 1);      // NaN

NaN NaN NaN NaN NaN

NaN korrekt erkennen mit Number.isNaN()

const berechne = (eingabe) => {
  const wert = Number(eingabe);
  if (Number.isNaN(wert)) {
    console.error(`Ungültige Eingabe: "${eingabe}" ist keine Zahl.`);
    return null;
  }
  return wert * 2;
};

console.log(berechne("42"));    // 84
console.log(berechne("abc"));   // Fehlerausgabe + null
console.log(berechne(""));      // 0 (leerer String → 0)
console.log(berechne(null));    // 0 (null → 0)

84 Ungültige Eingabe: "abc" ist keine Zahl. null 0 0

Warum NaN !== NaN gilt und isNaN() vs. Number.isNaN()

console.log(NaN === NaN);           // false – NaN ist nicht sich selbst gleich
console.log(NaN == NaN);            // false

// Globales isNaN() konvertiert den Wert zuerst (Vorsicht!)
console.log(isNaN("abc"));          // true  – String wird zu NaN konvertiert
console.log(isNaN(undefined));      // true  – undefined wird zu NaN konvertiert

// Number.isNaN() prüft STRIKT ohne Typkonvertierung
console.log(Number.isNaN("abc"));   // false – kein NaN-Wert, nur ein String
console.log(Number.isNaN(NaN));     // true
console.log(Number.isNaN(Number.NaN)); // true – identisch mit NaN

false false true true false true true

// Wichtig · Fallstricke

Fallstricke:

typeof NaN ergibt "number" — dies ist historisch bedingt und oft verwirrend. Es bedeutet lediglich, dass NaN Teil des numerischen Typs ist, nicht, dass es eine sinnvolle Zahl ist.
Das globale isNaN() führt eine implizite Typkonvertierung durch und kann daher irreführende Ergebnisse liefern (z. B. isNaN("abc") === true). Bevorzuge stets Number.isNaN() für präzise Prüfungen.
NaN propagiert sich: Sobald eine Berechnung NaN enthält, ist das gesamte Ergebnis NaN. Dies kann zu schwer auffindbaren Fehlern führen, wenn Eingaben nicht vorab validiert werden.
Die globale Eigenschaft NaN ist seit ES5 nicht überschreibbar (writable: false, configurable: false). In sehr alten Umgebungen (ES3) konnte NaN noch überschrieben werden — dies ist in modernem JavaScript kein Problem mehr.

Siehe auch

Number.isNaN() isNaN() Number.NaN isFinite() parseFloat() parseInt()