Number

Beschreibung

Zahlen werden am hufigsten in literaler Form wie 255 oder 3.14159 ausgedrckt. Die lexikalische Grammatik enthlt eine detailliertere Referenz.

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)

Ein Zahlenliteral wie 37 im JavaScript-Code ist ein Gleitkommawert und kein Integer. Es gibt keinen separaten Integer-Typ in der alltglichen Verwendung. (JavaScript hat auch einen BigInt Typ, aber dieser ist nicht dafr gedacht, Number im alltglichen Gebrauch zu ersetzen. 37 ist immer noch eine Zahl, kein BigInt.)

Wenn Number(value) als Funktion verwendet wird, konvertiert es einen String oder einen anderen Wert in den Typ Number. Wenn der Wert nicht konvertiert werden kann, gibt er NaN zurck.

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

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

Zahlencodierung

Der JavaScript Number Typ ist ein doppelt-genauer 64-Bit-binr formatierter IEEE 754 Wert, hnlich wie double in Java oder C#. Das bedeutet, dass er Bruchwerte darstellen kann, es gibt jedoch einige Grenzen hinsichtlich der Gre und Przision der gespeicherten Zahl. Kurz gesagt, eine IEEE 754 Gleitkommazahl mit doppelter Genauigkeit verwendet 64 Bits, um 3 Teile darzustellen:

• 1 Bit fr das Vorzeichen (positiv oder negativ)
• 11 Bits fr den Exponenten (-1022 bis 1023)
• 52 Bits fr die Mantisse (darstellend eine Zahl zwischen 0 und 1)

Die Mantisse (auch Signifikand genannt) ist der Teil der Zahl, der den tatschlichen Wert (bedeutende Ziffern) darstellt. Der Exponent ist die Potenz von 2, mit der die Mantisse multipliziert werden muss. Man kann es sich wie wissenschaftliche Notation vorstellen:

Die Mantisse wird mit 52 Bits gespeichert, die als Ziffern nach 1. in einer binren Bruchzahl interpretiert werden. Daher betrgt die Przision der Mantisse 2-52 (erhltlich ber Number.EPSILON), oder etwa 15 bis 17 signifikante Dezimalziffern; arithmetische Operationen ber diesem Przisionsniveau unterliegen dem Runden.

Der grte Wert, den eine Zahl halten kann, ist 21023 (2 - 2-52) (wobei der Exponent 1023 und die Mantisse 0.1111 in Basis 2 ist), was ber Number.MAX_VALUE erlangt werden kann. Werte, die hher sind, werden durch die spezielle Zahlkonstante Infinity ersetzt.

Ganze Zahlen knnen im Bereich von -253 + 1 bis 253 - 1 ohne Przisionsverlust dargestellt werden (erhltlich ber Number.MIN_SAFE_INTEGER und Number.MAX_SAFE_INTEGER), weil die Mantisse nur 53 Bits halten kann (einschlielich des fhrenden 1).

Mehr Details hierzu sind im ECMAScript-Standard beschrieben.

Typumwandlung von Zahlen

Viele eingebaute Operationen, die Zahlen erwarten, wandeln zuerst ihre Argumente in Zahlen um (was weitgehend der Grund ist, warum Number Objekte hnlich wie Zahlenprimitiven verhalten). Die Operation kann wie folgt zusammengefasst werden:

• Zahlen werden unverndert zurckgegeben.
• 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 Zahlenliteral enthalten. Bei Parsfehlern ergibt sich NaN. Es gibt einige kleine Unterschiede im Vergleich zu einem tatschlichen Zahlenliteral:
  • Fhrender und nachfolgender Leerraum/Zeilenabschlusszeichen werden ignoriert.
  • Eine fhrende 0-Ziffer fhrt nicht dazu, dass die Zahl zu einem oktalen Literal wird (oder in strict mode abgelehnt wird).
  • + und - sind am Anfang des Strings erlaubt, um das Vorzeichen anzuzeigen. (In tatschlichem Code scheinen sie Teil des Literals zu sein, sind aber tatschlich separate unre Operatoren.) Das Vorzeichen darf jedoch nur einmal erscheinen und darf nicht von Leerzeichen gefolgt werden.
  • Infinity und -Infinity werden als Literale erkannt. In tatschlichem Code sind sie globale Variablen.
  • Leere oder nur aus Leerzeichen bestehende Strings werden zu 0 konvertiert.
  • Nummerische Separatoren sind nicht erlaubt.
• BigInts lsen einen TypeError aus, um unbeabsichtigte implizite Typumwandlungen zu verhindern, die einen Przisionsverlust verursachen.
• Symbole lsen einen TypeError aus.
• Objekte werden zuerst in einen primitiven Wert umgewandelt, indem ihre [Symbol.toPrimitive]() (mit "number" als Hinweis), valueOf() und toString() Methoden in dieser Reihenfolge aufgerufen werden. Der resultierende primitive Wert wird dann in eine Zahl konvertiert.

Es gibt zwei Mglichkeiten, fast den gleichen Effekt in JavaScript zu erzielen.

• Einziges Pluszeichen: +x fhrt genau die oben beschriebenen Typumwandlungsschritte durch, um x zu konvertieren.
• Die Number() Funktion: Number(x) verwendet den gleichen Algorithmus, um x zu konvertieren, auer dass BigInts keinen TypeError auslsen, sondern ihren Zahlenwert zurckgeben, mit mglichem Przisionsverlust.

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

Ganzzahlkonvertierung

Einige Operationen erwarten Ganzzahlen, insbesondere diejenigen, die mit Array-/String-Indizes, Datum-/Zeitkomponenten und Zahlenradixen arbeiten. Nach Durchfhrung der obigen Typumwandlungsschritte wird das Ergebnis abgeschnitten, indem der Bruchteil entfernt wird. Wenn die Zahl Infinity ist, bleibt sie unverndert. Ist die Zahl NaN oder -0, wird 0 zurckgegeben. Das Ergebnis ist daher immer eine Ganzzahl (die nicht -0 ist) oder Infinity.

Bemerkenswert ist, dass undefined und null beim Umwandeln in Ganzzahlen zu 0 werden, weil undefined in NaN konvertiert wird, was auch zu 0 wird.

Festbreite-Typumwandlung von Zahlen

JavaScript hat einige Funktionen auf niedrigerer Ebene, die mit der binren Codierung von Ganzzahlen umgehen, insbesondere bitweise Operatoren und TypedArray Objekte. Bitweise Operatoren konvertieren die Operanden immer in 32-Bit-Ganzzahlen. In diesen Fllen wird nach der Konvertierung des Wertes in eine Zahl zunchst der Bruchteil abgeschnitten und dann die niedrigsten Bits in der Zweierkomplementcodierung der Ganzzahl genommen.

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)

Konstruktor

Number()

Erzeugt Number Objekte. Wenn sie als Funktion aufgerufen wird, gibt sie primitive Werte vom Typ Number zurck.

Statische Eigenschaften

Number.EPSILON

Das kleinste Intervall zwischen zwei darstellbaren Zahlen.

Number.MAX_SAFE_INTEGER

Die maximale sichere Ganzzahl in JavaScript (253 - 1).

Number.MAX_VALUE

Der grte positive darstellbare Wert.

Number.MIN_SAFE_INTEGER

Die minimale sichere Ganzzahl in JavaScript (-(253 - 1)).

Number.MIN_VALUE

Die kleinste positive darstellbare Zahldas heit, die positive Zahl, die null am nchsten kommt (ohne tatschlich null zu sein).

Number.NaN

Spezieller "Not a Number"-Wert.

Number.NEGATIVE_INFINITY

Spezieller Wert, der negative Unendlichkeit darstellt. Wird bei berlauf zurckgegeben.

Number.POSITIVE_INFINITY

Spezieller Wert, der Unendlichkeit darstellt. Wird bei berlauf zurckgegeben.

Statische Methoden

Number.isFinite()

Bestimmt, ob der bergebene Wert eine endliche Zahl ist.

Number.isInteger()

Bestimmt, ob der bergebene Wert eine Ganzzahl ist.

Number.isNaN()

Bestimmt, ob der bergebene Wert NaN ist.

Number.isSafeInteger()

Bestimmt, ob der bergebene Wert eine sichere Ganzzahl ist (Zahl zwischen -(253 - 1) und 253 - 1).

Number.parseFloat()

Dies ist das gleiche wie die globale parseFloat() Funktion.

Number.parseInt()

Dies ist das gleiche wie die globale parseInt() Funktion.

Instanz-Eigenschaften

Diese Eigenschaften sind auf Number.prototype definiert und werden von allen Number Instanzen geteilt.

Number.prototype.constructor

Die Konstruktionsfunktion, die das Instanzobjekt erstellt hat. Fr Number Instanzen ist der Anfangswert der Number Konstruktor.

Instanz-Methoden

Number.prototype.toExponential()

Gibt einen String zurck, der die Zahl in exponentielle Notation darstellt.

Number.prototype.toFixed()

Gibt einen String zurck, der die Zahl in Festkommanotation darstellt.

Number.prototype.toLocaleString()

Gibt einen String mit einer sprachsensitiven Darstellung dieser Zahl zurck. berschreibt die Object.prototype.toLocaleString() Methode.

Number.prototype.toPrecision()

Gibt einen String zurck, der die Zahl mit einer angegebenen Przision in Festkomma- oder Exponentialnotation darstellt.

Number.prototype.toString()

Gibt einen String zurck, der das angegebene Objekt in dem angegebenen Radix ("Basis") darstellt. berschreibt die Object.prototype.toString() Methode.

Number.prototype.valueOf()

Gibt den primitiven Wert des angegebenen Objekts zurck. berschreibt die Object.prototype.valueOf() Methode.

Beispiele

Verwendung des Number-Objekts zur Zuweisung von Werten zu numerischen Variablen

Das folgende Beispiel verwendet die Eigenschaften des Number Objekts, um mehreren numerischen Variablen Werte zuzuweisen:

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

Ganzzahlbereich fr Number

Im folgenden Beispiel werden die minimalen und maximalen Ganzzahlwerte angezeigt, die als Number Objekt dargestellt werden knnen.

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

Beim Parsen von Daten, die in JSON serialisiert wurden, knnen Ganzzahlen, die auerhalb dieses Bereichs liegen, beim Zuordnen zum Number Typ durch den JSON-Parser beschdigt werden.

Ein mglicher Workaround besteht darin, String zu verwenden.

Grere Zahlen knnen mit dem BigInt Typ dargestellt werden.

Verwendung von Number() zur Umwandlung eines Date-Objekts

Das folgende Beispiel konvertiert das Date Objekt in einen numerischen Wert, indem Number als Funktion verwendet wird:

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

Dies protokolliert 819199440000.

Numerische Strings und null in Zahlen umwandeln

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

Spezifikationen

Browser-Kompatibilitt

Siehe auch

• Polyfill des modernen Number-Verhaltens (mit Untersttzung fr binre und oktale Literale) in core-js
• NaN
• Arithmetische Operatoren
• Math
• BigInt