parseInt()

Функция parseInt() разбирает строковый аргумент и возвращает целое число указанной системы счисления (основания в математических системах счисления).

Попробуйте

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)

Синтаксис

parseInt(string)
parseInt(string, radix)

Параметры

string

Строка, начинающаяся с целого числа. Начальные пробельные символы в этом аргументе игнорируются.

radix Необязательный

Целое число в диапазоне от 2 до 36, представляющее систему счисления (основание в математических системах счисления) для string. Оно преобразуется в 32-битное целое число; если оно ненулевое и выходит за пределы диапазона [2, 36] после преобразования, функция всегда вернет NaN. Если 0 или не предоставлено, система счисления будет определена на основе значения string. Будьте осторожны — это не всегда по умолчанию 10! Описание ниже более подробно объясняет, что происходит, когда radix не предоставлено.

Возвращаемое значение

Целое число, полученное из предоставленного string, или NaN, когда

• radix в виде 32-битного целого числа меньше 2 или больше 36, или
• первый не-пробельный символ не может быть преобразован в число.

Описание

Функция parseInt преобразует свой первый аргумент в строку, разбирает эту строку, а затем возвращает целое число или NaN.

Если NaN не указано, возвращаемое значение будет целым числом, которое является первым аргументом, интерпретируемым как число в указанной radix. (Например, radix 10 преобразуется из десятичного числа, 8 — из восьмеричного, 16 — из шестнадцатеричного, и так далее).

Аргумент radix преобразуется в число. Если он не предоставлен, или если значение становится 0, NaN или Infinity (undefined приводится к NaN), JavaScript предполагает следующее:

1. Если входная строка string, с начальными пробелами и удаленными возможными знаками +/-, начинается с 0x или 0X (ноль, за которым следует строчная или заглавная X), предполагается, что radix равна 16, и остальная часть строки разбирается как шестнадцатеричное число.
2. Если входная строка string начинается с любого другого значения, система счисления равна 10 (десятичная).

Если система счисления равна 16, parseInt() разрешает строке быть опционально префиксированной 0x или 0X после опционального знака (+/-).

Если значение системы счисления (приведенное, если необходимо) находится вне диапазона [2, 36] (включительно), parseInt возвращает NaN.

Для систем счисления больше 10 буквы английского алфавита обозначают числа больше 9. Например, для шестнадцатеричных чисел (основание 16) используются A до F. Регистр букв не имеет значения.

parseInt понимает ровно два знака: + для положительного и - для отрицательного. Это делается в качестве первого шага при разборе после удаления пробельных символов. Если знаки не найдены, алгоритм переходит к следующему шагу; в противном случае он удаляет знак и выполняет разбор числа для оставшейся части строки.

Если parseInt встречает в строке ввода символ, который не является допустимой цифрой в указанной radix, он игнорирует его и все последующие символы и возвращает целочисленное значение, разобранное до этого момента. Например, parseInt("2", 2) возвращает NaN, потому что 2 не является допустимой цифрой в двоичной системе счисления. Аналогично, хотя 1e3 технически кодирует целое число (и будет правильно разобран до целого числа 1000 parseFloat()), parseInt("1e3", 10) возвращает 1, потому что e не является допустимой цифрой в основании 10. Поскольку . также не является цифрой, возвращаемое значение всегда будет целым числом.

Если первый символ не может быть преобразован в число с используемой системой счисления, parseInt возвращает NaN. Начальные пробелы допустимы.

Для арифметических целей значение NaN не является числом ни в одной системе счисления. Вы можете вызвать функцию Number.isNaN, чтобы определить, является ли результат parseInt NaN. Если NaN передается в арифметические операции, результат операции также будет NaN.

Поскольку большие числа используют символ e в своем строковом представлении (например, 6.022e23 для 6.022 × 10²³), использование parseInt для усечения чисел приведет к неожиданным результатам при использовании на очень больших или очень малых числах. parseInt не следует использовать в качестве замены Math.trunc().

Чтобы преобразовать число в его строковый литерал в определенной системе счисления, используйте thatNumber.toString(radix).

Поскольку parseInt() возвращает число, оно может страдать от потери точности, если целое число, представленное строкой, находится вне безопасного диапазона. Функция BigInt() поддерживает точный разбор целых чисел произвольной длины, возвращая BigInt.

Примеры

Использование parseInt()

Следующие примеры возвращают 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:

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

Следующие примеры возвращают -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:

parseInt("0e0", 16);

parseInt() не обрабатывает BigInt значения. Он останавливается на символе n и обрабатывает предыдущую строку как обычное целое число, с возможной потерей точности.

parseInt("900719925474099267n");
// 900719925474099300

Вместо этого следует передать строку в функцию BigInt(), без завершающего символа n.

BigInt("900719925474099267");
// 900719925474099267n

parseInt не работает с разделителями чисел:

parseInt("123_456"); // 123

Использование parseInt() на не-строках

parseInt() может давать интересные результаты при работе с не-строками в сочетании с высокой системой счисления; например, 36 (что делает все буквенно-цифровые символы допустимыми числовыми цифрами).

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(), — плохая идея. Это может работать на малых числах:

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() вернет одноразрядное целое число:

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()
• Number.parseFloat()
• Number.parseInt()
• isNaN()
• Number.prototype.toString()
• Object.prototype.valueOf()
• Конструктор BigInt()