parseInt()

string

Eine Zeichenfolge, die mit einer Ganzzahl beginnt. Führende Whitespace in diesem Argument werden ignoriert.

radix Optional

Eine Ganzzahl zwischen 2 und 36, die die Basis (das Basissystem 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 die Basis basierend auf dem Wert der string abgeleitet. Vorsicht — dies standardmäßig nicht immer auf 10! Die Beschreibung unten erklärt detaillierter, was passiert, wenn radix nicht angegeben ist.

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

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

Die Funktion parseInt konvertiert ihr erstes Argument in eine Zeichenfolge, analysiert diese Zeichenfolge und gibt eine Ganzzahl oder NaN zurück.

Wenn nicht NaN, ist der Rückgabewert die Ganzzahl, die das erste Argument genommen als Zahl in der angegebenen radix ist. (Beispielsweise konvertiert eine radix von 10 aus einer Dezimalzahl, 8 aus einer Oktalzahl, 16 aus einer Hexadezimalzahl usw.)

Das Argument radix wird in eine Zahl umgewandelt. Ist sie nicht angegeben oder wird der Wert 0, NaN oder Infinity (undefined wird in NaN umgewandelt), übernimmt JavaScript Folgendes:

1. Wenn die Eingabe-string, ohne führende Whitespaces und mögliche +/- Zeichen, mit 0x oder 0X (eine Null, gefolgt von einem Klein- oder Großbuchstaben X) beginnt, wird die radix als 16 angenommen und der Rest der Zeichenfolge als Hexadezimalzahl analysiert.
2. Wenn die Eingabe-string mit einem anderen Wert beginnt, ist die Basis 10 (Dezimal).

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

Wenn der Basenwert (falls erforderlich erzwungen) nicht im Bereich [2, 36] (einschließlich) liegt, gibt parseInt NaN zurück.

Für Basen über 10 geben Buchstaben des englischen Alphabets Ziffern größer als 9 an. Zum Beispiel werden für hexadezimale Zahlen (Basis 16) die Buchstaben A bis F verwendet. Die Buchstaben sind nicht case-sensitiv.

parseInt versteht genau zwei Vorzeichen: + für positiv und - für negativ. Dies wird als erster Schritt beim Parsen durchgeführt, nachdem Whitespaces entfernt wurden. Wenn keine Vorzeichen gefunden werden, fährt der Algorithmus mit dem nächsten Schritt fort; andernfalls entfernt er das Vorzeichen und führt das Zahlenparsing auf dem Rest der Zeichenfolge aus.

Wenn parseInt auf ein Zeichen stößt, das keine Ziffer in der angegebenen radix ist, ignoriert es dieses und alle folgenden Zeichen und gibt den bis zu diesem Punkt analysierten Ganzzahlwert zurück. Zum Beispiel, obwohl 1e3 technisch eine Ganzzahl kodiert (und korrekt von parseFloat() in die Ganzzahl 1000 analysiert wird), gibt parseInt("1e3", 10) 1 zurück, da e keine gültige Ziffer in Basis 10 ist. Da . auch keine Ziffer ist, ist der Rückgabewert immer eine Ganzzahl.

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

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

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

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

Da parseInt() eine Zahl zurückgibt, kann es zu einem Verlust an Genauigkeit kommen, wenn die Zahl, die durch die Zeichenfolge dargestellt wird, außerhalb des sicheren Bereichs liegt. Die Funktion BigInt() unterstützt das genaue Parsen 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() verarbeitet keine BigInt-Werte. Es hält am n-Zeichen an und behandelt die vorangegangene Zeichenfolge als normale Ganzzahl, mit möglichem Genauigkeitsverlust.

parseInt("900719925474099267n");
// 900719925474099300

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

BigInt("900719925474099267");
// 900719925474099267n

parseInt funktioniert nicht mit Zahl-Trennzeichen:

parseInt("123_456"); // 123

parseInt() kann interessante Ergebnisse liefern, wenn es bei Nicht-Zeichenfolgen in Kombination mit einer hohen Basis verwendet wird; zum Beispiel 36 (was alle alphanumerischen Zeichen als gültige numerische 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() bei Nicht-Zeichenfolgen zu verwenden, insbesondere um es als Ersatz für Math.trunc() zu verwenden. Es kann bei kleinen Zahlen funktionieren:

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

Es funktioniert jedoch nur zufällig, weil die Zeichenfolgenrepräsentation dieser Zahlen die grundlegende Bruchschreibweise ("15.99", "-15.1") verwendet, bei der parseInt() am Dezimalpunkt stoppt. Zahlen größer oder gleich 1e+21 oder kleiner oder gleich 1e-7 verwenden die exponentielle Notation ("1.5e+22", "1.51e-8") in ihrer Zeichenfolgenrepräsentation, und parseInt() wird am e-Zeichen oder Dezimalpunkt anhalten, die immer nach der ersten Ziffer kommen. Dies bedeutet, dass parseInt() bei großen und kleinen Zahlen eine einstellige Ganzzahl zurückgeben 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

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