Signatur
Beschreibung
Die Funktion parseInt() parst ein String-Argument und gibt eine Ganzzahl der angegebenen radix (der Basis in mathematischen Zahlensystemen) zurück.
Die Funktion parseInt konvertiert ihr erstes Argument in einen String, parst diesen String und gibt dann eine Ganzzahl oder NaN zurück.
Wenn der Rückgabewert nicht NaN ist, entspricht er der Ganzzahl, die das erste Argument als Zahl in der angegebenen radix interpretiert. (Beispielsweise konvertiert eine radix von 10 von einer Dezimalzahl, 8 von oktal, 16 von hexadezimal usw.)
Das Argument radix wird in eine Zahl konvertiert. Wenn es nicht angegeben wird oder wenn der Wert 0, NaN oder Infinity wird (undefined wird zu NaN gecastet), nimmt JavaScript Folgendes an:
- Wenn der Eingabe-
string, nach Entfernen führender Whitespaces und möglicher+/--Zeichen, mit0xoder0Xbeginnt (eine Null, gefolgt von einem kleinen oder großen X), wirdradixals16angenommen und der Rest des Strings als Hexadezimalzahl geparst. - Wenn der Eingabe-
stringmit einem anderen Wert beginnt, ist die Basis10(dezimal).
Wenn die Basis 16 ist, erlaubt parseInt(), dass der String optional mit 0x oder 0X nach dem optionalen Vorzeichen (+/-) beginnt.
Wenn der Basiswert (bei Bedarf gecastet) nicht im Bereich [2, 36] (inklusiv) liegt, gibt parseInt NaN zurück.
Für Basen über 10 zeigen Buchstaben des englischen Alphabets Ziffern größer als 9 an. Beispielsweise werden für hexadezimale Zahlen (Basis 16) A bis F verwendet. Die Buchstaben sind case-insensitive.
parseInt versteht genau zwei Vorzeichen: + für positiv und - für negativ. Dies erfolgt als erster Schritt beim Parsen nach dem Entfernen von Whitespace. Wenn keine Vorzeichen gefunden werden, geht der Algorithmus zum nächsten Schritt über; andernfalls entfernt er das Vorzeichen und führt das Zahlen-Parsen auf dem Rest des Strings aus.
Wenn parseInt im Eingabe-String ein Zeichen antrifft, das keine gültige Ziffer in der angegebenen radix ist, ignoriert es dieses und alle nachfolgenden Zeichen und gibt den bis zu diesem Punkt geparsten Ganzzahlwert zurück. Beispielsweise gibt parseInt("2", 2) NaN zurück, weil 2 keine gültige Ziffer im binären Zahlensystem ist. Auch wenn 1e3 technisch eine Ganzzahl kodiert (und von parseFloat() korrekt zur Ganzzahl 1000 geparst wird), gibt parseInt("1e3", 10) 1 zurück, weil e keine gültige Ziffer zur Basis 10 ist. Da . ebenfalls keine Ziffer ist, wird der Rückgabewert immer eine Ganzzahl sein.
Wenn das erste Zeichen nicht mit der verwendeten Basis in eine Zahl umgewandelt werden kann, gibt parseInt NaN zurück. Führender Whitespace ist erlaubt.
Für arithmetische Zwecke ist der NaN-Wert in keiner Basis eine Zahl. Sie können die Funktion Number.isNaN aufrufen, um zu bestimmen, 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 Zeichen e in ihrer String-Darstellung verwenden (z. B. 6.022e23 für 6,022 × 1023), führt die Verwendung von parseInt zum Abschneiden von Zahlen bei sehr großen oder sehr kleinen Zahlen zu unerwarteten Ergebnissen. parseInt sollte nicht als Ersatz für Math.trunc() verwendet werden.
Um eine Zahl in ihre String-Darstellung in einer bestimmten Basis zu konvertieren, verwenden Sie thatNumber.toString(radix).
Da parseInt() eine Zahl zurückgibt, kann sie an Präzisionsverlust leiden, wenn die durch den String repräsentierte Ganzzahl 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.
Parameter
| Name | Typ | Default | Beschreibung |
|---|---|---|---|
| $string Pflicht | string | — | Ein String, der mit einer Ganzzahl beginnt. Führender Whitespace in diesem Argument wird ignoriert. |
| $radix | number | — | Eine Ganzzahl zwischen 2 und 36, die die radix (die Basis in mathematischen Zahlensystemen) des string repräsentiert. Sie wird in eine 32-Bit-Ganzzahl konvertiert; wenn sie nach der Konvertierung ungleich null und außerhalb des Bereichs [2, 36] liegt, gibt die Funktion immer NaN zurück. Wenn 0 oder nicht angegeben, wird die Basis basierend auf dem Wert von string abgeleitet. Vorsicht — dies ist nicht immer standardmäßig 10! |
Rückgabewert
string geparste Ganzzahl 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 konvertiert werden kann.Beispiele
parseInt() verwenden
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);Beispiele, die NaN zurückgeben
parseInt("Hello", 8); // Not a number at all
parseInt("546", 2); // Digits other than 0 or 1 are invalid for binary radixBeispiele, die -15 zurückgeben
parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);Beispiel, das 224 zurückgibt
parseInt("0e0", 16);BigInt-Werte werden nicht unterstützt
parseInt("900719925474099267n");
// 900719925474099300Stattdessen BigInt() verwenden
BigInt("900719925474099267");
// 900719925474099267nFunktioniert nicht mit numerischen Separatoren
parseInt("123_456"); // 123parseInt() mit Nicht-Strings
parseInt(null, 36); // 1112745: The string "null" is 1112745 in base 36
parseInt(undefined, 36); // 86464843759093: The string "undefined" is 86464843759093 in base 36Bei kleinen Zahlen funktioniert es
parseInt(15.99, 10); // 15
parseInt(-15.1, 10); // -15Bei großen und kleinen Zahlen unerwartete Ergebnisse
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); // 1Interaktives Beispiel
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)// Wichtig · Fallstricke
parseInt() und parseFloat() unterscheiden sich nur in ihrem Parsing-Verhalten, aber nicht notwendigerweise in ihren Rückgabewerten. Beispielsweise geben parseInt("42") und parseFloat("42") denselben Wert zurück: eine Number 42. Andere Präfixe wie 0b, die in Zahlenliteralen gültig sind, werden von parseInt() als normale Ziffern behandelt. parseInt() behandelt Strings, die mit einer 0 beginnen, auch nicht als Oktalwerte. Das einzige Präfix, das parseInt() erkennt, ist 0x oder 0X für Hexadezimalwerte — alles andere wird als Dezimalwert geparst, wenn radix fehlt. Stattdessen können Number() oder BigInt() verwendet werden, um diese Präfixe zu parsen.