parseInt()
Baseline Widely available
This feature is well established and works across many devices and browser versions. It’s been available across browsers since July 2015.
Die parseInt()
-Funktion analysiert ein Zeichenfolgenargument und gibt eine ganze Zahl des angegebenen Radix (die Basis in mathematischen Zahlensystemen) zurück.
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 ganzen Zahl beginnt. Führende Leerzeichen in diesem Argument werden ignoriert.
radix
Optional-
Eine ganze Zahl zwischen
2
und36
, die die basis (die Basis in mathematischen Zahlensystemen) derstring
darstellt. Es wird in eine 32-Bit-Ganzzahl umgewandelt. Wenn es nach der Umwandlung nicht null ist und außerhalb des Bereichs [2, 36] liegt, wird die Funktion immerNaN
zurückgeben. Wenn0
oder nicht angegeben, wird die Basis basierend auf dem Wert derstring
ermittelt. Vorsicht — dies ist nicht immer standardmäßig10
! Die Beschreibung unten erklärt ausführlicher, was passiert, wennradix
nicht angegeben ist.
Rückgabewert
Eine ganze Zahl, die aus der angegebenen string
analysiert wurde, oder NaN
, wenn
- die
radix
als 32-Bit-Ganzzahl kleiner als2
oder größer als36
ist, oder - das erste nicht-Leerzeichen-Zeichen nicht in eine Zahl umgewandelt werden kann.
Hinweis:
JavaScript unterscheidet auf Sprachebene nicht zwischen "Gleitkommazahlen" und "ganzen Zahlen". parseInt()
und parseFloat()
unterscheiden sich nur in ihrem Parsing-Verhalten, aber nicht notwendigerweise in ihren Rückgabewerten. Zum Beispiel würden parseInt("42")
und parseFloat("42")
denselben Wert zurückgeben: eine Number
42.
Beschreibung
Die Funktion parseInt
konvertiert ihr erstes Argument in eine Zeichenfolge, analysiert diese Zeichenfolge und gibt dann eine ganze Zahl oder NaN
zurück.
Wenn der Rückgabewert nicht NaN
ist, ist er die ganze Zahl, die das erste Argument als Zahl in der angegebenen radix
darstellt. (Zum Beispiel konvertiert eine radix
von 10
aus einer Dezimalzahl, 8
aus einer Oktalzahl, 16
aus einer Hexadezimalzahl und so weiter.)
Das radix
-Argument wird in eine Zahl umgewandelt. Wenn es nicht angegeben ist oder wenn der Wert nach der Umwandlung 0
, NaN
oder Infinity
ist (undefined
wird in NaN
umgewandelt), nimmt JavaScript Folgendes an:
- Wenn die Eingabe-
string
nach Entfernen führender Leerzeichen und möglicher+
/-
-Zeichen mit0x
oder0X
(einer Null, gefolgt von einem Klein- oder Großbuchstaben X) beginnt, wirdradix
als16
angenommen und der Rest der Zeichenfolge als Hexadezimalzahl analysiert. - Wenn die Eingabe-
string
mit einem anderen Wert beginnt, ist die Basis10
(Dezimalwert).
Hinweis:
Andere Präfixe wie 0b
, die in Zahlliteralen gültig sind, werden von parseInt()
als normale Ziffern behandelt. parseInt()
behandelt Zeichenfolgen, die mit einem 0
-Zeichen beginnen, auch nicht als Oktalwerte. Das einzige Präfix, das parseInt()
erkennt, ist 0x
oder 0X
für Hexadezimalwerte — alles andere wird als Dezimalwert analysiert, wenn radix
fehlt. Number()
oder BigInt()
können stattdessen verwendet werden, um diese Präfixe zu analysieren.
Wenn die Basis 16
ist, erlaubt parseInt()
die Zeichenfolge optional mit 0x
oder 0X
nach dem optionalen Vorzeichenzeichen (+
/-
) zu versehen.
Wenn der Basiswert (falls erforderlich, umgewandelt) nicht im Bereich [2, 36] (einschließlich) liegt, gibt parseInt
NaN
zurück.
Für Basen über 10
kennzeichnen Buchstaben des englischen Alphabets Ziffern größer als 9
. Zum Beispiel werden für Hexadezimalzahlen (Basis 16
) A
bis F
verwendet. Die Buchstaben sind nicht case-sensitiv.
parseInt
versteht genau zwei Vorzeichen: +
für positiv und -
für negativ. Es wird als erster Schritt der Analyse durchgeführt, nachdem Leerzeichen entfernt wurden. Wenn keine Vorzeichen gefunden werden, geht der Algorithmus zum nächsten Schritt über; andernfalls wird das Vorzeichen entfernt und die Zahl-Parsing-Logik auf den Rest der Zeichenfolge angewendet.
Wenn parseInt
auf ein Zeichen trifft, das keine Ziffer in der angegebenen radix
ist, ignoriert es dieses und alle nachfolgenden Zeichen und gibt den bis zu diesem Punkt analysierten Ganzzahlwert zurück. Zum Beispiel, obwohl 1e3
technisch eine Ganzzahl encodiert (und korrekt als Ganzzahl 1000
durch parseFloat()
analysiert wird), gibt parseInt("1e3", 10)
1
zurück, weil 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 im Radix verwendeten Basis in eine Zahl konvertiert werden kann, gibt parseInt
NaN
zurück. Führende Leerzeichen sind zulässig.
Für mathematische Operationen ist der Wert NaN
keine Zahl in irgendeiner Basis. Sie können die Funktion Number.isNaN
verwenden, um festzustellen, ob das Ergebnis von parseInt
NaN
ist. Wenn NaN
an mathematische Operationen übergeben wird, wird das Ergebnis der Operation ebenfalls NaN
sein.
Da große Zahlen das Zeichen e
in ihrer Zeichenfolgendarstellung verwenden (z. B. 6.022e23
für 6.022 × 1023), führt die Verwendung von parseInt
zur Kürzung von Zahlen zu unerwarteten Ergebnissen, wenn es auf sehr große oder sehr kleine Zahlen angewendet wird. parseInt
sollte nicht als Ersatz für Math.trunc()
verwendet werden.
Um eine Zahl als Zeichenfolge in einer bestimmten Basis darzustellen, verwenden Sie thatNumber.toString(radix)
.
Da parseInt()
eine Zahl zurückgibt, kann es zu Präzisionsverlust kommen, wenn die durch die Zeichenfolge dargestellte Ganzzahl außerhalb des sicheren Bereichs liegt. Die Funktion BigInt()
unterstützt die genaue Analyse von Ganzzahlen beliebiger Länge, indem sie einen BigInt
zurückgibt.
Beispiele
Verwendung von parseInt()
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 stoppt beim Zeichen n
und behandelt die vorangehende Zeichenfolge als normale Ganzzahl, mit möglichem Präzisionsverlust.
parseInt("900719925474099267n");
// 900719925474099300
Sie sollten die Zeichenfolge stattdessen direkt an die Funktion BigInt()
übergeben, ohne das abschließende n
-Zeichen.
BigInt("900719925474099267");
// 900719925474099267n
parseInt
funktioniert nicht mit numerischen Trennzeichen:
parseInt("123_456"); // 123
Verwendung von parseInt() bei Nicht-Zeichenfolgen
parseInt()
kann interessante Ergebnisse liefern, wenn es auf Nicht-Zeichenfolgen zusammen mit einer hohen Basis angewendet wird; zum Beispiel 36
(was alle alphanumerischen Zeichen als gültige Ziffern zulässt).
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 keine gute Idee, parseInt()
bei Nicht-Zeichenfolgen zu verwenden, insbesondere um es als Ersatz für Math.trunc()
zu nutzen. Es kann bei kleinen Zahlen funktionieren:
parseInt(15.99, 10); // 15
parseInt(-15.1, 10); // -15
Es funktioniert jedoch nur zufällig, weil die Zeichenfolgendarstellung dieser Zahlen die einfache Bruchnotation ("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 in ihrer Zeichenfolgendarstellung die exponentielle Notation ("1.5e+22"
, "1.51e-8"
), und parseInt()
wird am Zeichen e
oder Dezimalpunkt, der immer nach der ersten Ziffer kommt, stoppen. Dies bedeutet, dass bei großen und kleinen Zahlen parseInt()
eine einstellige Ganzzahl 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
Spezifikationen
Specification |
---|
ECMAScript® 2025 Language Specification # sec-parseint-string-radix |
Browser-Kompatibilität
Report problems with this compatibility data on GitHubdesktop | mobile | server | ||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
parseInt | ||||||||||||||
Parses leading-zero strings as decimal, not octal |
Legend
Tip: you can click/tap on a cell for more information.
- Full support
- Full support