Die FunktionparseInt() analysiert ein Zeichenfolgen-Argument und gibt eine Ganzzahl der angegebenenBasis zurück (die Basis in mathematischen Zahlensystemen).

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. FührendeLeerzeichen in diesem Argument werden ignoriert.

radixOptional

Eine Ganzzahl zwischen2 und36, die dieBasis (die Basis in mathematischen Zahlensystemen) derstring darstellt. Sie wird zu einer32-Bit-Ganzzahl umgewandelt; wenn sie ein nicht-nuller Wert außerhalb des Bereichs [2, 36] nach der Umwandlung ist, gibt die Funktion immerNaN zurück. Wenn0 oder nicht angegeben, wird die Basis basierend auf dem Wert vonstring abgeleitet. Seien Sie vorsichtig — dies istnicht immer standardmäßig10! Dieuntenstehende Beschreibung erklärt detaillierter, was passiert, wenn die Basis nicht angegeben ist.

Rückgabewert

Eine aus der angegebenenstring geparste Ganzzahl oderNaN wenn

• die Basis als 32-Bit-Ganzzahl kleiner als2 oder größer als36 ist, oder
• das erste Nicht-Leerzeichen-Zeichen nicht in eine Zahl umgewandelt werden kann.

Beschreibung

DieparseInt-Funktionwandelt ihr erstes Argument in eine Zeichenfolge um, parst diese Zeichenfolge und gibt dann eine Ganzzahl oderNaN zurück.

Wenn nichtNaN, wird der Rückgabewert die Ganzzahl sein, die das erste Argument als Zahl in der angegebenenBasis ist. (Beispielsweise konvertiert eineBasis von10 aus einer Dezimalzahl,8 aus einer Oktalzahl,16 aus einer Hexadezimalzahl usw.)

Dasradix-Argument wird zu einer Zahlumgewandelt. Wenn es nicht bereitgestellt wird oder wenn der Wert 0,NaN oderInfinity wird (undefined wird zuNaN konvertiert), geht JavaScript wie folgt vor:

1. Wenn die Eingabe-string, mit führenden Leerzeichen und möglichen+/- Zeichen entfernt, mit0x oder0X (eine Null, gefolgt von einem Klein- oder Großbuchstaben X) beginnt, wird die Basis als16 angenommen und der Rest der Zeichenfolge als Hexadezimalzahl geparst.
2. Wenn die Eingabe-string mit einem anderen Wert beginnt, ist die Basis10 (Dezimal).

Wenn die Basis16 ist, erlaubtparseInt(), dass die Zeichenfolge optional nach dem optionalen Vorzeichenzeichen (+/-) mit0x oder0X versehen wird.

Wenn der Basiswert (bei Bedarf erzwungen) nicht im Bereich [2, 36] (einschließlich) liegt, gibtparseIntNaN zurück.

Für Basen größer als10 zeigen Buchstaben des englischen Alphabets Ziffern größer als9 an. Zum Beispiel werden für Hexadezimalzahlen (Basis16) die BuchstabenA bisF verwendet. Die Buchstaben sind nicht case-sensitiv.

parseInt versteht genau zwei Vorzeichen:+ für positiv und- für negativ. Dies wird als erster Schritt im Parsing 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 Zahlenanalyse auf den Rest der Zeichenfolge angewendet.

WennparseInt auf ein Zeichen in der Eingabezeichenfolge trifft, das in der angegebenen Basis keine gültige Ziffer ist, ignoriert es dieses und alle folgenden Zeichen und gibt den bis zu diesem Punkt geparsten Ganzzahlwert zurück. Zum Beispiel gibtparseInt("2", 2)NaN zurück, da2 im Binärsystem keine gültige Ziffer ist. Auch wenn1e3 technisch eine Ganzzahl kodiert (und korrekt vonparseFloat() in die Ganzzahl1000 geparst wird), gibtparseInt("1e3", 10)1 zurück, dae in der Basis 10 keine gültige Ziffer 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, gibtparseIntNaN zurück. Führende Leerzeichen sind erlaubt.

Für mathematische Zwecke ist derNaN-Wert in keiner Basis eine Zahl. Sie können die FunktionNumber.isNaN aufrufen, um festzustellen, ob das Ergebnis vonparseIntNaN ist. WennNaN an arithmetische Operationen weitergegeben wird, ist das Ergebnis der Operation ebenfallsNaN.

Da große Zahlen dase-Zeichen in ihrer String-Darstellung verwenden (z.B.6.022e23 für 6.022 × 10²³), wirdparseInt unerwartete Ergebnisse liefern, wenn es auf sehr große oder sehr kleine Zahlen angewendet wird.parseInt solltenicht als Ersatz fürMath.trunc() verwendet werden.

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

DaparseInt() eine Zahl zurückgibt, kann es zu einem Verlust der Genauigkeit kommen, wenn die von der Zeichenfolge dargestellte Ganzzahlaußerhalb des sicheren Bereichs liegt. Die FunktionBigInt() unterstützt das präzise Parsen von Ganzzahlen beliebiger Länge, indem sie einBigInt zurückgibt.

Beispiele

Verwendung von parseInt()

Die folgenden Beispiele geben alle15 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 alleNaN zurück:

parseInt("Hello", 8); // Not a number at allparseInt("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 gibt224 zurück:

parseInt("0e0", 16);

parseInt() verarbeitet keineBigInt-Werte. Es stoppt amn-Zeichen und behandelt die vorhergehende Zeichenfolge als normale Ganzzahl, mit möglichem Präzisionsverlust.

parseInt("900719925474099267n");// 900719925474099300

Sie sollten die Zeichenfolge stattdessen an die FunktionBigInt() ohne das abschließenden-Zeichen übergeben.

BigInt("900719925474099267");// 900719925474099267n

parseInt funktioniert nicht mitnumerischen 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 Beispiel36 (was alle alphanumerischen Zeichen zu gültigen Ziffern macht).

parseInt(null, 36); // 1112745: The string "null" is 1112745 in base 36parseInt(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 fürMath.trunc() zu verwenden. Es könnte bei kleinen Zahlen funktionieren:

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

Es passiert jedoch nur, weil die String-Darstellung dieser Zahlen grundlegende Bruchnotation ("15.99","-15.1") verwendet, wobeiparseInt() am Dezimalpunkt stoppt. Zahlen größer als oder gleich1e+21 oder kleiner als oder gleich1e-7 verwenden in ihrer Zeichenfolgen-Darstellung die Exponentialnotation ("1.5e+22","1.51e-8"), undparseInt() wird ame-Zeichen oder Dezimalpunkt stoppen, der immer nach der ersten Ziffer kommt. Das bedeutet, dassparseInt() bei großen und kleinen Zahlen eine einstellige Ganzzahl zurückgeben wird:

parseInt(4.7 * 1e22, 10); // Very large number becomes 4parseInt(0.00000000000434, 10); // Very small number becomes 4parseInt(0.0000001, 10); // 1parseInt(0.000000123, 10); // 1parseInt(1e-7, 10); // 1parseInt(1000000000000000000000, 10); // 1parseInt(123000000000000000000000, 10); // 1parseInt(1e21, 10); // 1

Spezifikationen

Browser-Kompatibilität

Siehe auch

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