parseInt()

¥Syntax

parseInt(string)
parseInt(string, radix)

¥Parameters

string

以整数开头的字符串。该参数中的前导 whitespace 将被忽略。

radix Optional

介于 2 和 36 之间的整数，表示 string 的基数（数学数字系统中的基数）。它被转换为 32 位整数；如果转换后非零且超出 [2, 36] 范围，则函数将始终返回 NaN。如果未提供 0，则将根据 string 的值推断基数。请小心 — 这并不总是默认为 10！描述如下 更详细地解释了未提供 radix 时会发生的情况。

¥Return value

从给定的 string 或 NaN 解析的整数

¥An integer parsed from the given string, or NaN when

• 作为 32 位整数的 radix 小于 2 或大于 36，或者
• 第一个非空白字符无法转换为数字。

注意：JavaScript 在语言层面上没有 "浮点数字" 和 "integers" 的区别。parseInt() 和 parseFloat() 仅在解析行为上有所不同，但其返回值不一定不同。例如，parseInt("42") 和 parseFloat("42") 将返回相同的值：Number 42。

¥Note: JavaScript does not have the distinction of "floating point numbers" and "integers" on the language level. parseInt() and parseFloat() only differ in their parsing behavior, but not necessarily their return values. For example, parseInt("42") and parseFloat("42") would return the same value: a Number 42.

¥Description

parseInt 函数 将其第一个参数转换为字符串 解析该字符串，然后返回一个整数或 NaN。

¥The parseInt function converts its first argument to a string, parses that string, then returns an integer or NaN.

如果不是 NaN，则返回值将是作为指定 radix 中的数字的第一个参数的整数。（例如，radix 或 10 从十进制转换，8 从八进制转换，16 从十六进制转换，依此类推。）

¥If not NaN, the return value will be the integer that is the first argument taken as a number in the specified radix. (For example, a radix of 10 converts from a decimal number, 8 converts from octal, 16 from hexadecimal, and so on.)

radix 参数是 转换为数字。如果未提供，或者值变为 0、NaN 或 Infinity（undefined 被强制为 NaN），JavaScript 会假设以下内容：

¥The radix argument is converted to a number. If it's unprovided, or if the value becomes 0, NaN or Infinity (undefined is coerced to NaN), JavaScript assumes the following:

1. 如果输入 string（删除了前导空格和可能的 +/- 符号）以 0x 或 0X（零，后跟小写或大写 X）开头，则 radix 被假定为 16，并且字符串的其余部分被解析为十六进制 数字。
2. 如果输入 string 以任何其他值开头，则基数为 10（十进制）。

注意：其他前缀（如 0b）在 数字字面量 中有效，但在 parseInt() 中被视为普通数字。parseInt() 也不会将以 0 字符开头的字符串视为八进制值。parseInt() 识别的唯一前缀是十六进制值的 0x 或 0X — 如果缺少 radix，则其他所有内容都将解析为十进制值。可以使用 Number() 或 BigInt() 来解析这些前缀。

¥Note: Other prefixes like 0b, which are valid in number literals, are treated as normal digits by parseInt(). parseInt() does not treat strings beginning with a 0 character as octal values either. The only prefix that parseInt() recognizes is 0x or 0X for hexadecimal values — everything else is parsed as a decimal value if radix is missing. Number() or BigInt() can be used instead to parse these prefixes.

如果基数为 16，parseInt() 允许字符串在可选的符号字符 (+/-) 后可选地添加 0x 或 0X 前缀。

¥If the radix is 16, parseInt() allows the string to be optionally prefixed by 0x or 0X after the optional sign character (+/-).

如果基值（必要时进行强制）不在范围 [2, 36]（含）内，则 parseInt 返回 NaN。

¥If the radix value (coerced if necessary) is not in range [2, 36] (inclusive) parseInt returns NaN.

对于 10 以上的基数，英文字母表示大于 9 的数字。例如，对于十六进制数（基数 16），使用 A 到 F。字母不区分大小写。

¥For radices above 10, letters of the English alphabet indicate numerals greater than 9. For example, for hexadecimal numbers (base 16), A through F are used. The letters are case-insensitive.

parseInt 准确理解两个符号：+ 为正，- 为负。它是在删除空格后作为解析的初始步骤完成的。如果没有找到迹象，算法将进入下一步；否则，它会删除符号并对字符串的其余部分运行数字解析。

¥parseInt understands exactly two signs: + for positive, and - for negative. It is done as an initial step in the parsing after whitespace is removed. If no signs are found, the algorithm moves to the following step; otherwise, it removes the sign and runs the number-parsing on the rest of the string.

如果 parseInt 在指定的 radix 中遇到不是数字的字符，它将忽略该字符以及所有后续字符，并返回到该点解析的整数值。例如，尽管 1e3 在技术上编码了一个整数（并且将被 parseFloat() 正确解析为整数 1000），但 parseInt("1e3", 10) 返回 1，因为 e 不是以 10 为基数的有效数字。由于 . 也不是数字，因此返回值始终是整数。

¥If parseInt encounters a character that is not a numeral in the specified radix, it ignores it and all succeeding characters and returns the integer value parsed up to that point. For example, although 1e3 technically encodes an integer (and will be correctly parsed to the integer 1000 by parseFloat()), parseInt("1e3", 10) returns 1, because e is not a valid numeral in base 10. Because . is not a numeral either, the return value will always be an integer.

如果第一个字符无法转换为使用所用基数的数字，则 parseInt 返回 NaN。允许使用前导空格。

¥If the first character cannot be converted to a number with the radix in use, parseInt returns NaN. Leading whitespace is allowed.

出于算术目的，NaN 值不是任何基数的数字。你可以调用 Number.isNaN 函数来确定 parseInt 的结果是否为 NaN。如果将 NaN 传递给算术运算，则运算结果也将是 NaN。

¥For arithmetic purposes, the NaN value is not a number in any radix. You can call the Number.isNaN function to determine if the result of parseInt is NaN. If NaN is passed on to arithmetic operations, the operation result will also be NaN.

由于大数字在其字符串表示形式中使用 e 字符（例如 6.022e23 表示 6.022 × 10²³），因此当用于非常大或非常小的数字时，使用 parseInt 截断数字会产生意外结果。parseInt 不应用作 Math.trunc() 的替代品。

¥Because large numbers use the e character in their string representation (e.g. 6.022e23 for 6.022 × 10²³), using parseInt to truncate numbers will produce unexpected results when used on very large or very small numbers. parseInt should not be used as a substitute for Math.trunc().

要将数字转换为其特定基数的字符串文字，请使用 thatNumber.toString(radix)。

¥To convert a number to its string literal in a particular radix, use thatNumber.toString(radix).

由于 parseInt() 返回一个数字，因此如果字符串表示的整数是 超出安全范围，则可能会导致精度损失。BigInt() 函数通过返回 BigInt 来支持精确解析任意长度的整数。

¥Because parseInt() returns a number, it may suffer from loss of precision if the integer represented by the string is outside the safe range. The BigInt() function supports parsing integers of arbitrary length accurately, by returning a BigInt.

¥Examples

¥Using parseInt()

以下示例均返回 15：

¥The following examples all return 15:

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);

以下示例均返回 NaN：

¥The following examples all return NaN:

parseInt("Hello", 8); // Not a number at all
parseInt("546", 2); // Digits other than 0 or 1 are invalid for binary radix

以下示例均返回 -15：

¥The following examples all return -15:

parseInt("-F", 16);
parseInt("-0F", 16);
parseInt("-0XF", 16);
parseInt("-17", 8);
parseInt("-15", 10);
parseInt("-1111", 2);
parseInt("-15e1", 10);
parseInt("-12", 13);

以下示例返回 224：

¥The following example returns 224:

parseInt("0e0", 16);

parseInt() 不处理 BigInt 值。它在 n 字符处停止，并将前面的字符串视为普通整数，但可能会损失精度。

¥parseInt() does not handle BigInt values. It stops at the n character, and treats the preceding string as a normal integer, with possible loss of precision.

parseInt("900719925474099267n");
// 900719925474099300

你应该将字符串传递给 BigInt() 函数，而不带尾随 n 字符。

¥You should pass the string to the BigInt() function instead, without the trailing n character.

BigInt("900719925474099267");
// 900719925474099267n

parseInt 不适用于 数字分隔符：

¥parseInt doesn't work with numeric separators:

parseInt("123_456"); // 123

¥Using parseInt() on non-strings

当处理非字符串与高基数结合时，parseInt() 可以产生有趣的结果；例如，36（这使得所有字母数字字符成为有效的数字）。

¥parseInt() can have interesting results when working on non-strings combined with a high radix; for example, 36 (which makes all alphanumeric characters valid numeric digits).

parseInt(null, 36); // 1112745: The string "null" is 1112745 in base 36
parseInt(undefined, 36); // 86464843759093: The string "undefined" is 86464843759093 in base 36

一般来说，在非字符串上使用 parseInt() 是一个坏主意，尤其是用它来代替 Math.trunc()。它可能适用于小数字：

¥In general, it's a bad idea to use parseInt() on non-strings, especially to use it as a substitution for Math.trunc(). It may work on small numbers:

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

但是，它只是碰巧起作用，因为这些数字的字符串表示形式使用基本分数表示法 ("15.99", "-15.1")，其中 parseInt() 在小数点处停止。大于或等于 1e+21 或小于或等于 1e-7 的数字在其字符串表示中使用指数表示法 ("1.5e+22", "1.51e-8")，parseInt() 将停止在 e 字符或小数点处，该字符始终位于第一个数字之后 。这意味着对于大数和小数，parseInt() 将返回一位整数：

¥However, it only happens to work because the string representation of these numbers uses basic fractional notation ("15.99", "-15.1"), where parseInt() stops at the decimal point. Numbers greater than or equal to 1e+21 or less than or equal to 1e-7 use exponential notation ("1.5e+22", "1.51e-8") in their string representation, and parseInt() will stop at the e character or decimal point, which always comes after the first digit. This means for large and small numbers, parseInt() will return a one-digit integer:

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

¥See also

• parseFloat()
• Number() 构造函数
• Number.parseFloat()
• Number.parseInt()
• isNaN()
• Number.prototype.toString()
• Object.prototype.valueOf()
• BigInt() 构造函数