NaN

Der gleiche Zahlenwert wie Number.NaN.

NaN ist eine Eigenschaft des globalen Objekts. Mit anderen Worten, es ist eine Variable im globalen Gültigkeitsbereich.

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

Es gibt fünf verschiedene Arten von Operationen, die NaN zurückgeben:

• Fehlgeschlagene Zahlenkonvertierung (z. B. explizit wie parseInt("blabla"), Number(undefined), oder implizit wie Math.abs(undefined))
• Mathematische Operationen, bei denen das Ergebnis keine reelle 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 Operand NaN ist oder zu NaN gezwungen wird (z. B. 7 ** NaN, 7 * "blabla") — das bedeutet, NaN ist ansteckend
• Andere Fälle, in denen ein ungültiger Wert als Zahl dargestellt werden soll (z. B. ein ungültiges Datum new Date("blabla").getTime(), "".charCodeAt(1))

NaN und sein Verhalten wurden nicht von JavaScript erfunden. Seine Semantik in der Gleitkommaarithmetik (einschließlich, dass NaN !== NaN) wird von IEEE 754 spezifiziert. Zu den Verhaltensweisen von NaN gehören:

• Wenn NaN an einer mathematischen Operation beteiligt ist (aber nicht an bitweisen Operationen), ist das Ergebnis normalerweise auch NaN. (Siehe Gegenbeispiel unten.)
• Wenn NaN einer der Operanden eines relationalen Vergleichs (>, <, >=, <=) ist, ist das Ergebnis immer false.
• NaN wird bei Vergleichen (mit ==, !=, ===, und !==) zu jedem anderen Wert ungleich bewertet — einschließlich einem anderen NaN Wert.

NaN ist auch einer der falsy Werte in JavaScript.

Um festzustellen, ob ein Wert NaN ist, verwenden Sie Number.isNaN() oder isNaN(), um am klarsten zu bestimmen, ob ein Wert NaN ist — oder, da NaN der einzige Wert ist, der ungleich zu sich selbst ist, Sie können einen Selbstvergleich wie x !== x durchführen.

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 zurück, wenn der Wert derzeit NaN ist, oder wenn er NaN sein wird, nachdem er zu einer Zahl gezwungen wurde, während Letzteres true nur zurückgibt, wenn der Wert derzeit NaN ist:

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

Aus demselben Grund wird bei Verwendung eines BigInt-Werts ein Fehler mit isNaN() ausgelöst und nicht mit Number.isNaN():

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

Zusätzlich können einige Array-Methoden NaN nicht finden, während andere dies können. Nämlich, die Index-finden-Methoden (indexOf(), lastIndexOf()) können NaN nicht finden, während die Wert-finden-Methoden (includes()) dies können:

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

Für weitere Informationen über NaN und dessen Vergleich, siehe Vergleich auf Gleichheit und Gleichartigkeit.

Es ist möglich, zwei Gleitkommazahlen mit unterschiedlichen Binärdarstellungen zu erzeugen, die beide NaN sind, da in IEEE 754-Codierung jede Gleitkommazahl mit dem Exponenten 0x7ff und einer nicht-null Mantisse NaN ist. In JavaScript können Sie bitweise Manipulation mit typisierten Arrays durchführen.

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]

NaN pflanzt sich durch mathematische Operationen fort, daher reicht es normalerweise aus, einmal am Ende der Berechnung auf NaN zu testen, um Fehlerbedingungen zu erkennen. Der einzige Fall, in dem NaN stillschweigend entkommt, ist bei Verwendung der Exponentiation mit einem Exponenten von 0, die sofort 1 zurückgibt, ohne den Basiswert zu testen.

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

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