NaN - JavaScript | MDN

Seitenleiste umschalten

Farbschema

Systemeinstellung
Hell
Dunkel

Deutsch

Sprache merken Mehr erfahren

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 NaN globale Eigenschaft ist ein Wert, der „Nicht eine Zahl“ (Not-a-Number) darstellt.

In diesem Artikel

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.

Eigenschaften von NaN

Schreibbar	nein
Aufzählbar	nein
Konfigurierbar	nein

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 fünf verschiedene Typen von Operationen, die NaN zurückgeben:

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 Fälle, in denen ein ungültiger Wert als Zahl dargestellt werden soll (z. B. ein ungültiges Datum (Date) 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) ist durch IEEE 754 spezifiziert. Zu den Verhaltensweisen von NaN gehören:

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 Größenordnung (>, <, >=, <=) ist, ist das Ergebnis immer false.
NaN vergleicht ungleich (über ==, !=, === und !==) mit jedem anderen Wert – einschließlich 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, können Sie einen Selbstvergleich wie x !== x durchführen.

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

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

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

js
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. Namentlich die Methoden zum Finden von Indizes (indexOf(), lastIndexOf()) können NaN nicht finden, während die Methoden zum Finden von Werten (includes()) dies können:

js
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 von Gleichheit und Identität.

Beobachtbar unterschiedliche NaN-Werte

Es ist möglich, zwei Gleitkommazahlen mit unterschiedlichen Binärdarstellungen 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 können Sie Bit-Ebene-Manipulationen mit typisierten Arrays durchführen.

js
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 zurückgibt, ohne den Wert der Basis zu testen.

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

Help improve MDN

War diese Übersetzung hilfreich?

Ja Nein

Erfahren Sie, wie Sie beitragen können Diese Seite wurde automatisch aus dem Englischen übersetzt.

Übersetzung auf GitHub anzeigen • Fehler mit dieser Übersetzung melden

NaN