NaN

Probieren Sie es aus

function sanitize(x) {
  if (isNaN(x)) {
    return NaN;
  }
  return x;
}

console.log(sanitize("1"));
// Expected output: "1"

console.log(sanitize("NotANumber"));
// Expected output: NaN

Wert

Der gleiche Zahlenwert wie Number.NaN.

Beschreibung

NaN ist eine Eigenschaft des globalen Objekts. In anderen Worten, es ist eine Variable im globalen Bereich.

In modernen Browsern ist NaN eine nicht konfigurierbare, nicht beschreibbare Eigenschaft. Auch wenn dies nicht der Fall ist, vermeiden Sie es, sie zu berschreiben.

Es gibt fnf verschiedene Typen von Operationen, die NaN zurckgeben:

• Fehlgeschlagene Zahlenkonvertierung (z. B. explizite wie parseInt("blabla"), Number(undefined) oder implizite wie Math.abs(undefined))
• Mathematische Operation, deren Ergebnis keine reale Zahl ist (z. B. Math.sqrt(-1))
• Unbestimmte Form (z. B. 0 * Infinity, 1 ** Infinity, Infinity / Infinity, Infinity - Infinity)
• Eine Methode oder ein Ausdruck, dessen Operanden NaN sind oder zu NaN gezwungen werden (z. B. 7 ** NaN, 7 * "blabla") das bedeutet, NaN ist ansteckend
• Andere Flle, in denen ein ungltiger Wert als Zahl dargestellt werden soll (z. B. ein ungltiges Datum (Date) new Date("blabla").getTime(), "".charCodeAt(1))

NaN und sein Verhalten wurden nicht von JavaScript erfunden. Seine Semantik in der Gleitkommaarithmetik (einschlielich dass NaN !== NaN) ist durch IEEE 754 spezifiziert. Zu den Verhaltensweisen von NaN gehren:

• Wenn NaN an einer mathematischen Operation beteiligt ist (aber nicht bei bitweisen Operationen), ist das Ergebnis normalerweise auch NaN. (Siehe Gegenbeispiel unten.)
• Wenn NaN einer der Operanden eines Vergleichs der relationalen Grenordnung (>, <, >=, <=) ist, ist das Ergebnis immer false.
• NaN vergleicht ungleich (ber ==, !=, === und !==) mit jedem anderen Wert einschlielich eines anderen NaN-Werts.

NaN ist auch einer der falsy Werte in JavaScript.

Beispiele

Testen gegen NaN

Um festzustellen, ob ein Wert NaN ist, verwenden Sie Number.isNaN() oder isNaN(), um am deutlichsten zu bestimmen, ob ein Wert NaN ist oder, da NaN der einzige Wert ist, der ungleich zu sich selbst ist, knnen Sie einen Selbstvergleich wie x !== x durchfhren.

NaN === NaN; // false
Number.NaN === NaN; // false
isNaN(NaN); // true
isNaN(Number.NaN); // true
Number.isNaN(NaN); // true

function valueIsNaN(v) {
  return v !== v;
}
valueIsNaN(1); // false
valueIsNaN(NaN); // true
valueIsNaN(Number.NaN); // true

Beachten Sie jedoch den Unterschied zwischen isNaN() und Number.isNaN(): Ersteres gibt true zurck, wenn der Wert momentan NaN ist oder NaN wird, nachdem es zu einer Zahl gezwungen wurde, whrend Letzteres nur dann true zurckgibt, wenn der Wert momentan NaN ist:

isNaN("hello world"); // true
Number.isNaN("hello world"); // false

Aus dem gleichen Grund fhrt die Verwendung eines BigInt-Werts zu einem Fehler mit isNaN() und nicht mit Number.isNaN():

isNaN(1n); // TypeError: Conversion from 'BigInt' to 'number' is not allowed.
Number.isNaN(1n); // false

Zustzlich knnen einige Array-Methoden NaN nicht finden, whrend andere dies knnen. Namentlich die Methoden zum Finden von Indizes (indexOf(), lastIndexOf()) knnen NaN nicht finden, whrend die Methoden zum Finden von Werten (includes()) dies knnen:

const arr = [2, 4, NaN, 12];
arr.indexOf(NaN); // -1
arr.includes(NaN); // true

// Methods accepting a properly defined predicate can always find NaN
arr.findIndex((n) => Number.isNaN(n)); // 2

Fr weitere Informationen ber NaN und dessen Vergleich siehe Vergleich von Gleichheit und Identitt.

Beobachtbar unterschiedliche NaN-Werte

Es ist mglich, zwei Gleitkommazahlen mit unterschiedlichen Binrdarstellungen zu erzeugen, die beide NaN sind, denn in der IEEE 754 Kodierung ist jede Gleitkommazahl mit Exponent 0x7ff und einer nicht-null Mantisse NaN. In JavaScript knnen Sie Bit-Ebene-Manipulationen mit typisierten Arrays durchfhren.

const f2b = (x) => new Uint8Array(new Float64Array([x]).buffer);
const b2f = (x) => new Float64Array(x.buffer)[0];
// Get a byte representation of NaN
const n = f2b(NaN);
const m = f2b(NaN);
// Change the sign bit, which doesn't matter for NaN
n[7] += 2 ** 7;
// n[0] += 2**7; for big endian processors
const nan2 = b2f(n);
console.log(nan2); // NaN
console.log(Object.is(nan2, NaN)); // true
console.log(f2b(NaN)); // Uint8Array(8) [0, 0, 0, 0, 0, 0, 248, 127]
console.log(f2b(nan2)); // Uint8Array(8) [0, 0, 0, 0, 0, 0, 248, 255]
// Change the first bit, which is the least significant bit of the mantissa and doesn't matter for NaN
m[0] = 1;
// m[7] = 1; for big endian processors
const nan3 = b2f(m);
console.log(nan3); // NaN
console.log(Object.is(nan3, NaN)); // true
console.log(f2b(NaN)); // Uint8Array(8) [0, 0, 0, 0, 0, 0, 248, 127]
console.log(f2b(nan3)); // Uint8Array(8) [1, 0, 0, 0, 0, 0, 248, 127]

Still entkommendes NaN

NaN breitet sich durch mathematische Operationen aus, daher reicht es in der Regel aus, am Ende der Berechnung einmal auf NaN zu testen, um Fehlerbedingungen zu erkennen. Der einzige Fall, in dem NaN unbemerkt entkommt, ist bei der Verwendung von Potenzierung mit einem Exponenten von 0, was sofort 1 zurckgibt, ohne den Wert der Basis zu testen.

NaN ** 0 === 1; // true

Spezifikationen

Browser-Kompatibilitt

Siehe auch

• Number.NaN
• Number.isNaN()
• isNaN()