NaN
Baseline
Weitgehend verfügbar
Diese Funktion ist gut etabliert und funktioniert auf vielen Geräten und in vielen Browserversionen. Sie ist seit Juli 2015 browserübergreifend verfügbar.
Die globale Eigenschaft NaN ist ein Wert, der „Not-A-Number“ (keine Zahl) repräsentiert.
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
Derselbe Zahlenwert wie Number.NaN.
Eigenschaften von NaN | |
|---|---|
| Schreibbar | nein |
| Aufzählbar | nein |
| Konfigurierbar | nein |
Beschreibung
NaN ist eine Eigenschaft des globalen Objekts. Anders ausgedrückt: Es ist eine Variable im globalen Gültigkeitsbereich.
In modernen Browsern ist NaN eine nicht konfigurierbare, schreibgeschützte Eigenschaft. Auch wenn das nicht der Fall ist, sollten Sie sie nicht überschreiben.
Fünf verschiedene Arten von Operationen geben NaN zurück:
- Fehlgeschlagene Umwandlungen in eine Zahl (z. B. explizite Umwandlungen wie
parseInt("blabla")oderNumber(undefined)sowie implizite Umwandlungen wieMath.abs(undefined)) - Mathematische Operationen, deren Ergebnis keine reelle Zahl ist (z. B.
Math.sqrt(-1)) - Unbestimmte Ausdrücke (z. B.
0 * Infinity,1 ** Infinity,Infinity / Infinity,Infinity - Infinity) - Methoden oder Ausdrücke, deren Operand
NaNist oder inNaNumgewandelt wird (z. B.7 ** NaN,7 * "blabla") – das bedeutet, dass sichNaNweiterverbreitet - Andere Fälle, in denen ein ungültiger Wert als Zahl dargestellt werden soll (z. B. das Ergebnis von
new Date("blabla").getTime()für ein ungültiges Date oder von"".charCodeAt(1))
NaN und sein Verhalten wurden nicht von JavaScript erfunden. Seine Semantik in der Gleitkommaarithmetik (einschließlich NaN !== NaN) ist durch IEEE 754 festgelegt. Für NaN gilt unter anderem:
- Wenn
NaNan einer mathematischen Operation beteiligt ist (außer an bitweisen Operationen), ist das Ergebnis normalerweise ebenfallsNaN. (Siehe das Gegenbeispiel unten.) - Wenn
NaNeiner der Operanden eines relationalen Vergleichs (>,<,>=,<=) ist, ist das Ergebnis immerfalse. NaNwird bei Vergleichen mit==,!=,===und!==als ungleich zu jedem anderen Wert bewertet – auch zu einem anderenNaN-Wert.
NaN gehört in JavaScript außerdem zu den falsy-Werten.
Beispiele
>Auf NaN prüfen
Um festzustellen, ob ein Wert NaN ist, verwenden Sie am besten Number.isNaN() oder isNaN(). Da NaN der einzige Wert ist, der im Vergleich mit sich selbst als ungleich bewertet wird, können Sie auch 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 bereits NaN ist oder nach der Umwandlung in eine Zahl NaN wäre. Letzteres gibt nur dann true zurück, wenn der Wert bereits NaN ist:
isNaN("hello world"); // true
Number.isNaN("hello world"); // false
Aus demselben Grund führt ein BigInt-Wert bei isNaN() zu einem Fehler, bei Number.isNaN() hingegen nicht:
isNaN(1n); // TypeError: Conversion from 'BigInt' to 'number' is not allowed.
Number.isNaN(1n); // false
Außerdem können manche Array-Methoden NaN nicht finden, andere dagegen schon. Die Methoden zur Indexsuche (indexOf(), lastIndexOf()) können NaN nicht finden, die Methode zur Wertsuche (includes()) hingegen schon:
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
Weitere Informationen zu NaN und Vergleichen damit finden Sie unter Gleichheitsvergleiche und Gleichheit.
Unterscheidbare NaN-Werte
Es ist möglich, zwei Gleitkommazahlen mit unterschiedlichen binären Darstellungen zu erzeugen, die beide NaN sind. Denn gemäß der IEEE-754-Kodierung ist jede Gleitkommazahl mit dem Exponenten 0x7ff und einer von null verschiedenen Mantisse NaN. In JavaScript können Sie mithilfe von typisierten Arrays Operationen auf Bitebene 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]
Wenn sich NaN unbemerkt nicht weiterverbreitet
NaN verbreitet sich bei mathematischen Operationen weiter. Daher reicht es normalerweise aus, am Ende einer Berechnung einmal auf NaN zu prüfen, um Fehlerzustände zu erkennen. Ein Fall, in dem sich NaN unbemerkt nicht weiterverbreitet, ist die Potenzierung mit dem Exponenten 0: Sie gibt sofort 1 zurück, ohne den Wert der Basis zu prüfen. Weitere Fälle betreffen Funktionen von Math, etwa Math.hypot(), das Infinity Vorrang vor NaN gibt.
NaN ** 0 === 1; // true
Spezifikationen
| Spezifikation |
|---|
| ECMAScript® 2027 Language Specification> # sec-value-properties-of-the-global-object-nan> |