Number — Klasse · JavaScript-Referenz

Signatur

Number

Beschreibung

Number-Werte repräsentieren Gleitkommazahlen wie 37 oder -9.25.

Der Number-Konstruktor enthält Konstanten und Methoden für die Arbeit mit Zahlen. Werte anderer Typen können mithilfe der Number()-Funktion in Zahlen konvertiert werden.

Zahlen werden am häufigsten in literaler Form wie 255 oder 3.14159 ausgedrückt. Die lexikalische Grammatik enthält eine detailliertere Referenz.

Ein Zahlliteral wie 37 in JavaScript-Code ist ein Gleitkommawert, keine Ganzzahl. Es gibt keinen separaten Ganzzahl-Typ im alltäglichen Gebrauch. (JavaScript hat auch einen BigInt-Typ, aber er ist nicht dafür gedacht, Number für alltägliche Anwendungen zu ersetzen. 37 ist immer noch eine Number, kein BigInt.)

Wenn als Funktion verwendet, konvertiert Number(value) einen String oder anderen Wert in den Number-Typ. Wenn der Wert nicht konvertiert werden kann, wird NaN zurückgegeben.

Number-Kodierung

Der JavaScript-Number-Typ ist ein IEEE 754 Binärformat mit doppelter Genauigkeit (64 Bit), ähnlich double in Java oder C#. Das bedeutet, er kann gebrochene Werte darstellen, aber es gibt einige Grenzen für die Größenordnung und Präzision der gespeicherten Zahl. Sehr kurz: Eine IEEE 754 Zahl mit doppelter Genauigkeit verwendet 64 Bit zur Darstellung von 3 Teilen:

1 Bit für das Vorzeichen (positiv oder negativ)
11 Bits für den Exponenten (-1022 bis 1023)
52 Bits für die Mantisse (repräsentiert eine Zahl zwischen 0 und 1)

Die Mantisse (auch Signifikand genannt) ist der Teil der Zahl, der den tatsächlichen Wert (signifikante Stellen) repräsentiert. Der Exponent ist die Potenz von 2, mit der die Mantisse multipliziert werden soll.

Die Mantisse wird mit 52 Bits gespeichert, interpretiert als Ziffern nach 1.… in einer binären Bruchzahl. Daher ist die Präzision der Mantisse 2^-52 (erhältlich über Number.EPSILON), oder etwa 15 bis 17 signifikante Dezimalstellen; Arithmetik oberhalb dieser Präzisionsstufe unterliegt Rundung.

Der größte Wert, den eine Number aufnehmen kann, ist 2¹⁰²³ × (2 - 2^-52) (mit dem Exponenten 1023 und der Mantisse 0.1111… zur Basis 2), erhältlich über Number.MAX_VALUE. Höhere Werte werden durch die spezielle Zahlenkonstante Infinity ersetzt.

Ganzzahlen können nur ohne Präzisionsverlust im Bereich von -2⁵³ + 1 bis 2⁵³ - 1 einschließlich dargestellt werden (erhältlich über Number.MIN_SAFE_INTEGER und Number.MAX_SAFE_INTEGER), weil die Mantisse nur 53 Bits (einschließlich der führenden 1) aufnehmen kann.

Number-Koerzion

Viele eingebaute Operationen, die Zahlen erwarten, koerzieren ihre Argumente zunächst zu Zahlen (weshalb sich Number-Objekte weitgehend ähnlich wie Number-Primitives verhalten). Die Operation kann wie folgt zusammengefasst werden:

Numbers werden unverändert zurückgegeben.
undefined wird zu NaN.
null wird zu 0.
true wird zu 1; false wird zu 0.
Strings werden konvertiert, indem sie geparst werden, als ob sie ein Zahlliteral enthielten. Ein Parsing-Fehler ergibt NaN. Es gibt einige kleinere Unterschiede im Vergleich zu einem tatsächlichen Zahlliteral:
- Führende und nachgestellte Leerzeichen/Zeilenumbrüche werden ignoriert.
- Eine führende Ziffer 0 führt nicht dazu, dass die Zahl zu einem Oktalliteral wird (oder im Strict Mode abgelehnt wird).
- + und - sind am Anfang des Strings erlaubt, um dessen Vorzeichen anzugeben. (In tatsächlichem Code „sehen sie aus" wie Teil des Literals, sind aber tatsächlich separate unäre Operatoren.) Das Vorzeichen darf jedoch nur einmal erscheinen und darf nicht von Leerzeichen gefolgt werden.
- Infinity und -Infinity werden als Literale erkannt. In tatsächlichem Code sind sie globale Variablen.
- Leere Strings oder Strings, die nur aus Leerzeichen bestehen, werden zu 0 konvertiert.
- Numerische Trennzeichen sind nicht erlaubt.
BigInts werfen einen TypeError, um unbeabsichtigte implizite Koerzion zu verhindern, die zu Präzisionsverlust führen würde.
Symbols werfen einen TypeError.
Objekte werden zunächst zu einem Primitive konvertiert, indem ihre [Symbol.toPrimitive]()- (mit "number" als Hint), valueOf()- und toString()-Methoden in dieser Reihenfolge aufgerufen werden. Das resultierende Primitive wird dann zu einer Number konvertiert.

Es gibt zwei Wege, in JavaScript nahezu denselben Effekt zu erzielen:

Unäres Plus: +x führt genau die oben erklärten Number-Koerzionsschritte aus, um x zu konvertieren.
Die Number()-Funktion: Number(x) verwendet denselben Algorithmus zur Konvertierung von x, außer dass BigInts keinen TypeError werfen, sondern ihren Number-Wert zurückgeben, mit möglichem Präzisionsverlust.

Number.parseFloat() und Number.parseInt() sind ähnlich zu Number(), konvertieren aber nur Strings und haben leicht unterschiedliche Parsing-Regeln. Zum Beispiel erkennt parseInt() den Dezimalpunkt nicht, und parseFloat() erkennt das 0x-Präfix nicht.

Integer-Konvertierung

Einige Operationen erwarten Ganzzahlen, insbesondere solche, die mit Array-/String-Indizes, Datum-/Zeit-Komponenten und Zahlenbasen arbeiten. Nach dem Ausführen der obigen Number-Koerzionsschritte wird das Ergebnis auf eine Ganzzahl abgeschnitten (durch Verwerfen des Bruchteils). Wenn die Zahl ±Infinity ist, wird sie unverändert zurückgegeben. Wenn die Zahl NaN oder -0 ist, wird sie als 0 zurückgegeben. Das Ergebnis ist daher immer eine Ganzzahl (die nicht -0 ist) oder ±Infinity.

Bemerkenswert ist, dass sowohl undefined als auch null bei Konvertierung zu Ganzzahlen zu 0 werden, weil undefined zu NaN konvertiert wird, was ebenfalls zu 0 wird.

Konvertierung von Zahlen mit fester Breite

JavaScript hat einige Low-Level-Funktionen, die mit der binären Kodierung von Ganzzahlen umgehen, insbesondere Bitwise-Operatoren und TypedArray-Objekte. Bitwise-Operatoren konvertieren die Operanden immer in 32-Bit-Ganzzahlen. In diesen Fällen wird der Wert nach der Konvertierung in eine Number auf die gegebene Breite normalisiert, indem zunächst der Bruchteil abgeschnitten wird und dann die niedrigsten Bits in der Zweierkomplement-Kodierung der Ganzzahl genommen werden.

Parameter

Name	Typ	Default	Beschreibung
$value	any	0	Der Wert, der in eine Zahl umgewandelt werden soll. Wird `Number()` ohne `new` aufgerufen, gibt es den primitiven numerischen Wert zurück. Mit `new Number(value)` entsteht ein `Number`-Wrapper-Objekt.

Rückgabewert

Typ

number | Number

Beschreibung

Ohne new: ein primitiver number-Wert. Mit new: ein Number-Wrapper-Objekt (selten sinnvoll).

Beispiele

Zahlliterale

255; // two-hundred and fifty-five
255.0; // same number
255 === 255.0; // true
255 === 0xff; // true (hexadecimal notation)
255 === 0b11111111; // true (binary notation)
255 === 0.255e3; // true (decimal exponential notation)

Number() zur Konvertierung

Number("123"); // returns the number 123
Number("123") === 123; // true

Number("unicorn"); // NaN
Number(undefined); // NaN

Fixed-width Number-Konvertierung

new Int32Array([1.1, 1.9, -1.1, -1.9]); // Int32Array(4) [ 1, 1, -1, -1 ]

new Int8Array([257, -257]); // Int8Array(2) [ 1, -1 ]
// 257 = 0001 0000 0001
//     =      0000 0001 (mod 2^8)
//     = 1
// -257 = 1110 1111 1111
//      =      1111 1111 (mod 2^8)
//      = -1 (as signed integer)

new Uint8Array([257, -257]); // Uint8Array(2) [ 1, 255 ]
// -257 = 1110 1111 1111
//      =      1111 1111 (mod 2^8)
//      = 255 (as unsigned integer)

Number-Objekt zur Zuweisung von Werten an numerische Variablen verwenden

const biggestNum = Number.MAX_VALUE;
const smallestNum = Number.MIN_VALUE;
const infiniteNum = Number.POSITIVE_INFINITY;
const negInfiniteNum = Number.NEGATIVE_INFINITY;
const notANum = Number.NaN;

Integer-Bereich für Number

const biggestInt = Number.MAX_SAFE_INTEGER; // (2**53 - 1) => 9007199254740991
const smallestInt = Number.MIN_SAFE_INTEGER; // -(2**53 - 1) => -9007199254740991

Number() zur Konvertierung eines Date-Objekts

const d = new Date("1995-12-17T03:24:00");
console.log(Number(d));

819199440000

Numerische Strings und null in Zahlen konvertieren

Number("123"); // 123
Number("123") === 123; // true
Number("12.3"); // 12.3
Number("12.00"); // 12
Number("123e-1"); // 12.3
Number(""); // 0
Number(null); // 0
Number("0x11"); // 17
Number("0b11"); // 3
Number("0o11"); // 9
Number("foo"); // NaN
Number("100a"); // NaN
Number("-Infinity"); // -Infinity

// Wichtig · Fallstricke

IEEE-754-Präzision: Da JavaScript number als 64-Bit-Double speichert, können Dezimalbrüche wie 0.1 nicht exakt binär dargestellt werden. Für finanzielle Berechnungen immer Number.EPSILON als Toleranz nutzen oder auf spezialisierte Bibliotheken (z. B. decimal.js) zurückgreifen.

new Number() vermeiden: Ein mit new Number(5) erzeugtes Objekt ist kein primitiver Wert — typeof new Number(5) === "object". Das führt bei Vergleichen mit === zu überraschenden Ergebnissen. Stets ohne new aufrufen, wenn Typumwandlung gewünscht ist.

Sehr große Ganzzahlen: Für Werte jenseits von Number.MAX_SAFE_INTEGER (z. B. 64-Bit-IDs aus Datenbanken) sollte BigInt verwendet werden, da Number dort die Präzision verliert.

NaN-Vergleiche: NaN === NaN ist immer false. Zur Prüfung auf NaN stets Number.isNaN() verwenden – das globale isNaN() konvertiert seinen Argument erst und kann zu Fehlergebnissen führen.

Siehe auch

NaN Math BigInt