parseInt()

string

Eine Zeichenfolge, die mit einer ganzen Zahl beginnt. Führende Leerzeichen in diesem Argument werden ignoriert.

radix Optional

Eine ganze Zahl zwischen 2 und 36, die den Radix (die Basis in mathematischen Zahlensystemen) der string darstellt. Sie wird in eine 32-Bit-Ganzzahl umgewandelt; wenn sie ungleich null und außerhalb des Bereichs von [2, 36] nach der Umwandlung ist, gibt die Funktion immer NaN zurück. Wenn 0 oder nicht angegeben, wird der Radix basierend auf dem Wert von string abgeleitet. Seien Sie vorsichtig — dies wird nicht immer auf 10 gesetzt! Die Beschreibung unten erklärt detaillierter, was passiert, wenn radix nicht angegeben wird.

Eine ganze Zahl, die aus der angegebenen string analysiert wurde, oder NaN, wenn

• der radix als 32-Bit-Ganzzahl kleiner als 2 oder größer als 36 ist, oder
• das erste Nicht-Leerzeichen-Zeichen nicht in eine Zahl umgewandelt werden kann.

Die parseInt-Funktion wandelt ihr erstes Argument in eine Zeichenfolge um, analysiert diese Zeichenfolge und gibt dann eine ganze Zahl oder NaN zurück.

Wenn nicht NaN, ist der Rückgabewert die ganze Zahl, die das erste Argument als Zahl im angegebenen radix ist. (Zum Beispiel wandelt ein radix von 10 aus einer Dezimalzahl um, 8 aus einer Oktalzahl, 16 aus einer Hexadezimalzahl usw.)

Das radix-Argument wird in eine Zahl umgewandelt. Wenn es nicht angegeben ist, oder wenn der Wert 0, NaN oder Infinity wird (undefined wird in NaN umgewandelt), geht JavaScript von folgenden Annahmen aus:

1. Wenn die Eingabe-string, mit entfernten führenden Leerzeichen und möglichen +/--Zeichen, mit 0x oder 0X beginnt (eine Null, gefolgt von einem kleinen oder großen X), wird radix als 16 angenommen und der Rest der Zeichenfolge wird als Hexadezimalzahl analysiert.
2. Wenn die Eingabe-string mit einem anderen Wert beginnt, ist der Radix 10 (Dezimal).

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

Wenn der Radix-Wert (falls erforderlich, umgewandelt) nicht im Bereich [2, 36] (inklusive) liegt, gibt parseInt NaN zurück.

Für Radixe über 10 zeigen Buchstaben des englischen Alphabets Ziffern größer als 9 an. Beispielsweise werden für Hexadezimalzahlen (Basis 16) A bis F verwendet. Die Buchstaben sind nicht case-sensitiv.

parseInt versteht exakt zwei Vorzeichen: + für positiv und - für negativ. Dies geschieht als erster Schritt bei der Analyse, nachdem Leerzeichen entfernt wurden. Wenn keine Vorzeichen gefunden werden, fährt der Algorithmus mit dem nächsten Schritt fort; sonst wird das Vorzeichen entfernt und die Zahl-Parsing auf den Rest der Zeichenfolge angewandt.

Wenn parseInt ein Zeichen in der Eingabezeichenfolge antrifft, das keine gültige Ziffer im angegebenen radix ist, ignoriert es es und alle folgenden Zeichen und gibt den bis zu diesem Punkt analysierten ganzzahligen Wert zurück. Zum Beispiel gibt parseInt("2", 2) NaN zurück, weil 2 im binären Zahlensystem keine gültige Ziffer ist. Ebenso kodiert 1e3 technisch gesehen eine ganze Zahl (und wird korrekt in die ganze Zahl 1000 durch parseFloat() analysiert), aber parseInt("1e3", 10) gibt 1 zurück, da e keine gültige Ziffer in der Basis 10 ist. Weil auch . keine Ziffer ist, ist der Rückgabewert immer eine ganze Zahl.

Wenn das erste Zeichen nicht in eine Zahl mit dem verwendeten Radix umgewandelt werden kann, gibt parseInt NaN zurück. Führende Leerzeichen sind erlaubt.

Für arithmetische Zwecke ist der NaN-Wert in keinem Radix eine Zahl. Sie können die Funktion Number.isNaN aufrufen, um festzustellen, ob das Ergebnis von parseInt NaN ist. Wenn NaN an arithmetische Operationen übergeben wird, ist das Ergebnis der Operation ebenfalls NaN.

Da große Zahlen das e-Zeichen in ihrer Zeichenfolgenrepräsentation verwenden (z.B. 6.022e23 für 6.022 × 10²³), führt die Verwendung von parseInt, um Zahlen zu kürzen, zu unerwarteten Ergebnissen, wenn sie auf sehr große oder sehr kleine Zahlen angewendet wird. parseInt sollte nicht als Ersatz für Math.trunc() verwendet werden.

Um eine Zahl in ihren Zeichenfolgenliteral in einem bestimmten Radix umzuwandeln, verwenden Sie thatNumber.toString(radix).

Da parseInt() eine Zahl zurückgibt, kann es zu einem Verlust der Genauigkeit kommen, wenn die von der Zeichenfolge dargestellte ganze Zahl außerhalb des sicheren Bereichs liegt. Die Funktion BigInt() unterstützt das genaue Analysieren von Ganzzahlen beliebiger Länge, indem sie ein BigInt zurückgibt.

Die folgenden Beispiele geben alle 15 zurück:

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 zurück:

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 zurück:

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 zurück:

parseInt("0e0", 16);

parseInt() behandelt keine BigInt-Werte. Es stoppt am n-Zeichen und behandelt die vorhergehende Zeichenfolge als normale ganze Zahl, mit eventuell möglichem Präzisionsverlust.

parseInt("900719925474099267n");
// 900719925474099300

Sie sollten die Zeichenfolge stattdessen an die BigInt()-Funktion übergeben, ohne das abschließende n-Zeichen.

BigInt("900719925474099267");
// 900719925474099267n

parseInt funktioniert nicht mit Zifferntrennzeichen:

parseInt("123_456"); // 123

parseInt() kann interessante Ergebnisse liefern, wenn es auf Nicht-Zeichenfolgen angewendet wird, kombiniert mit einem hohen Radix; zum Beispiel 36 (was alle alphanumerischen Zeichen zu gültigen 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 zu verwenden, insbesondere als Ersatz für Math.trunc(). Es kann bei kleinen Zahlen funktionieren:

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

Dies passiert jedoch nur, weil die Zeichenfolgenrepräsentation dieser Zahlen die grundlegende Bruchnotation verwendet ("15.99", "-15.1"), wobei parseInt() am Dezimalpunkt stoppt. Zahlen größer als oder gleich 1e+21 oder kleiner als oder gleich 1e-7 verwenden in ihrer Zeichenfolgenrepräsentation die Exponentialnotation ("1.5e+22", "1.51e-8"), und parseInt() stoppt am e-Zeichen oder Dezimalpunkt, der immer nach der ersten Ziffer kommt. Dies bedeutet, dass parseInt() für große und kleine Zahlen eine einstellige ganze Zahl zurückgibt:

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

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