parseInt()

Probieren Sie es aus

console.log(parseInt("123"));
// 123 (default base-10)
console.log(parseInt("123", 10));
// 123 (explicitly specify base-10)
console.log(parseInt("   123 "));
// 123 (whitespace is ignored)
console.log(parseInt("077"));
// 77 (leading zeros are ignored)
console.log(parseInt("1.9"));
// 1 (decimal part is truncated)
console.log(parseInt("ff", 16));
// 255 (lower-case hexadecimal)
console.log(parseInt("0xFF", 16));
// 255 (upper-case hexadecimal with "0x" prefix)
console.log(parseInt("xyz"));
// NaN (input can't be converted to an integer)

Syntax

parseInt(string)
parseInt(string, radix)

Parameter

string

Eine Zeichenfolge, die mit einer Ganzzahl beginnt. Fhrende Leerzeichen in diesem Argument werden ignoriert.

radix Optional

Eine Ganzzahl zwischen 2 und 36, die die Basis (die Basis in mathematischen Zahlensystemen) der string darstellt. Sie wird zu einer 32-Bit-Ganzzahl umgewandelt; wenn sie ein nicht-nuller Wert auerhalb des Bereichs [2, 36] nach der Umwandlung ist, gibt die Funktion immer NaN zurck. Wenn 0 oder nicht angegeben, wird die Basis basierend auf dem Wert von string abgeleitet. Seien Sie vorsichtig dies ist nicht immer standardmig 10! Die untenstehende Beschreibung erklrt detaillierter, was passiert, wenn die Basis nicht angegeben ist.

Rckgabewert

Eine aus der angegebenen string geparste Ganzzahl oder NaN wenn

• die Basis als 32-Bit-Ganzzahl kleiner als 2 oder grer als 36 ist, oder
• das erste Nicht-Leerzeichen-Zeichen nicht in eine Zahl umgewandelt werden kann.

Beschreibung

Die parseInt-Funktion wandelt ihr erstes Argument in eine Zeichenfolge um, parst diese Zeichenfolge und gibt dann eine Ganzzahl oder NaN zurck.

Wenn nicht NaN, wird der Rckgabewert die Ganzzahl sein, die das erste Argument als Zahl in der angegebenen Basis ist. (Beispielsweise konvertiert eine Basis von 10 aus einer Dezimalzahl, 8 aus einer Oktalzahl, 16 aus einer Hexadezimalzahl usw.)

Das radix-Argument wird zu einer Zahl umgewandelt. Wenn es nicht bereitgestellt wird oder wenn der Wert 0, NaN oder Infinity wird (undefined wird zu NaN konvertiert), geht JavaScript wie folgt vor:

1. Wenn die Eingabe-string, mit fhrenden Leerzeichen und mglichen +/- Zeichen entfernt, mit 0x oder 0X (eine Null, gefolgt von einem Klein- oder Grobuchstaben X) beginnt, wird die Basis als 16 angenommen und der Rest der Zeichenfolge als Hexadezimalzahl geparst.
2. Wenn die Eingabe-string mit einem anderen Wert beginnt, ist die Basis 10 (Dezimal).

Wenn die Basis 16 ist, erlaubt parseInt(), dass die Zeichenfolge optional nach dem optionalen Vorzeichenzeichen (+/-) mit 0x oder 0X versehen wird.

Wenn der Basiswert (bei Bedarf erzwungen) nicht im Bereich [2, 36] (einschlielich) liegt, gibt parseInt NaN zurck.

Fr Basen grer als 10 zeigen Buchstaben des englischen Alphabets Ziffern grer als 9 an. Zum Beispiel werden fr Hexadezimalzahlen (Basis 16) die Buchstaben A bis F verwendet. Die Buchstaben sind nicht case-sensitiv.

parseInt versteht genau zwei Vorzeichen: + fr positiv und - fr negativ. Dies wird als erster Schritt im Parsing durchgefhrt, nachdem Leerzeichen entfernt wurden. Wenn keine Vorzeichen gefunden werden, geht der Algorithmus zum nchsten Schritt ber; andernfalls wird das Vorzeichen entfernt und die Zahlenanalyse auf den Rest der Zeichenfolge angewendet.

Wenn parseInt auf ein Zeichen in der Eingabezeichenfolge trifft, das in der angegebenen Basis keine gltige Ziffer ist, ignoriert es dieses und alle folgenden Zeichen und gibt den bis zu diesem Punkt geparsten Ganzzahlwert zurck. Zum Beispiel gibt parseInt("2", 2) NaN zurck, da 2 im Binrsystem keine gltige Ziffer ist. Auch wenn 1e3 technisch eine Ganzzahl kodiert (und korrekt von parseFloat() in die Ganzzahl 1000 geparst wird), gibt parseInt("1e3", 10) 1 zurck, da e in der Basis 10 keine gltige Ziffer ist. Da . ebenfalls keine Ziffer ist, wird der Rckgabewert immer eine Ganzzahl sein.

Wenn das erste Zeichen nicht mit der verwendeten Basis in eine Zahl umgewandelt werden kann, gibt parseInt NaN zurck. Fhrende Leerzeichen sind erlaubt.

Fr mathematische Zwecke ist der NaN-Wert in keiner Basis eine Zahl. Sie knnen die Funktion Number.isNaN aufrufen, um festzustellen, ob das Ergebnis von parseInt NaN ist. Wenn NaN an arithmetische Operationen weitergegeben wird, ist das Ergebnis der Operation ebenfalls NaN.

Da groe Zahlen das e-Zeichen in ihrer String-Darstellung verwenden (z.B. 6.022e23 fr 6.022 1023), wird parseInt unerwartete Ergebnisse liefern, wenn es auf sehr groe oder sehr kleine Zahlen angewendet wird. parseInt sollte nicht als Ersatz fr Math.trunc() verwendet werden.

Um eine Zahl in ihre Zeichenfolgenliteralform in einer bestimmten Basis zu konvertieren, verwenden Sie thatNumber.toString(radix).

Da parseInt() eine Zahl zurckgibt, kann es zu einem Verlust der Genauigkeit kommen, wenn die von der Zeichenfolge dargestellte Ganzzahl auerhalb des sicheren Bereichs liegt. Die Funktion BigInt() untersttzt das przise Parsen von Ganzzahlen beliebiger Lnge, indem sie ein BigInt zurckgibt.

Beispiele

Verwendung von parseInt()

Die folgenden Beispiele geben alle 15 zurck:

parseInt("0xF", 16);
parseInt("F", 16);
parseInt("17", 8);
parseInt("015", 10);
parseInt("15,123", 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15 * 3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);

Die folgenden Beispiele geben alle NaN zurck:

parseInt("Hello", 8); // Not a number at all
parseInt("546", 2); // Digits other than 0 or 1 are invalid for binary radix

Die folgenden Beispiele geben alle -15 zurck:

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

Das folgende Beispiel gibt 224 zurck:

parseInt("0e0", 16);

parseInt() verarbeitet keine BigInt-Werte. Es stoppt am n-Zeichen und behandelt die vorhergehende Zeichenfolge als normale Ganzzahl, mit mglichem Przisionsverlust.

parseInt("900719925474099267n");
// 900719925474099300

Sie sollten die Zeichenfolge stattdessen an die Funktion BigInt() ohne das abschlieende n-Zeichen bergeben.

BigInt("900719925474099267");
// 900719925474099267n

parseInt funktioniert nicht mit numerischen Trennern:

parseInt("123_456"); // 123

Verwendung von parseInt() auf Nicht-Zeichenfolgen

parseInt() kann interessante Ergebnisse liefern, wenn es auf Nicht-Zeichenfolgen in Kombination mit einer hohen Basis angewendet wird; zum Beispiel 36 (was alle alphanumerischen Zeichen zu gltigen Ziffern macht).

parseInt(null, 36); // 1112745: The string "null" is 1112745 in base 36
parseInt(undefined, 36); // 86464843759093: The string "undefined" is 86464843759093 in base 36

Im Allgemeinen ist es eine schlechte Idee, parseInt() auf Nicht-Zeichenfolgen anzuwenden, insbesondere es als Ersatz fr Math.trunc() zu verwenden. Es knnte bei kleinen Zahlen funktionieren:

parseInt(15.99, 10); // 15
parseInt(-15.1, 10); // -15

Es passiert jedoch nur, weil die String-Darstellung dieser Zahlen grundlegende Bruchnotation ("15.99", "-15.1") verwendet, wobei parseInt() am Dezimalpunkt stoppt. Zahlen grer als oder gleich 1e+21 oder kleiner als oder gleich 1e-7 verwenden in ihrer Zeichenfolgen-Darstellung die Exponentialnotation ("1.5e+22", "1.51e-8"), und parseInt() wird am e-Zeichen oder Dezimalpunkt stoppen, der immer nach der ersten Ziffer kommt. Das bedeutet, dass parseInt() bei groen und kleinen Zahlen eine einstellige Ganzzahl zurckgeben wird:

parseInt(4.7 * 1e22, 10); // Very large number becomes 4
parseInt(0.00000000000434, 10); // Very small number becomes 4

parseInt(0.0000001, 10); // 1
parseInt(0.000000123, 10); // 1
parseInt(1e-7, 10); // 1
parseInt(1000000000000000000000, 10); // 1
parseInt(123000000000000000000000, 10); // 1
parseInt(1e21, 10); // 1

Spezifikationen

Browser-Kompatibilitt

Siehe auch

• parseFloat()
• Number() Konstruktor
• Number.parseFloat()
• Number.parseInt()
• isNaN()
• Number.prototype.toString()
• Object.prototype.valueOf()
• BigInt() Konstruktor