parseInt()

Функція parseInt() (розібрати ціле число) розбирає рядковий аргумент і повертає ціле число за вказаною основою системи числення.

Спробуйте його в дії

Синтаксис

parseInt(string)
parseInt(string, radix)

Параметри

string (рядок)

Рядок, що починається з цілого числа. Пробіли на початку цього аргументу ігноруються.

radix (основа системи числення) Необов'язкове

Ціле число між 2 та 36, що представляє основу системи числення string. Воно перетворюється на 32-бітове ціле; якщо після перетворення воно ненульове і лежить поза діапазоном [2, 36], то функція поверне NaN. Якщо дорівнює 0 або не задане, то основа буде виведена на основі значення string. Будьте уважні: усталеним значенням не завжди є 10! Опис нижче більш детально пояснює, що відбувається, коли не надано radix.

Повернене значення

Ціле число, розібране з наданого рядка, або NaN, коли

• radix як 32-бітове число менше за 2 чи більше за 36, або
• перший непробільний символ не може бути перетворений на число.

Примітка: JavaScript не розрізняє "числа з рухомою комою" та "цілі числа" на рівні мови. parseInt() і parseFloat() відрізняються лише в логіці розбору, але не обов'язково повертають різні значення. Наприклад, parseInt("42") та parseFloat("42") повернуть одне й те ж значення – Number 42.

Опис

Функція parseInt перетворює свій перший аргумент на рядок, розбирає цей рядок, а потім повертає ціле число або NaN.

Якщо не NaN, то повернене значення буде цілим числом, що є першим аргументом, взятим як число за заданою основою числення. (Наприклад, основа числення 10 розбирає десяткові числа, 8 – вісімкові, 16 – шістнадцяткові, і так далі.)

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

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

Примітка: Інші префікси, наприклад, 0b, що є дійсними в числових літералах, обробляються parseInt() як звичайні цифри. Функція parseInt() також не обробляє рядки, що починаються з символу 0 як вісімкові значення. Єдиний префікс, котрий бере до уваги parseInt(), – 0x чи 0X для шістнадцяткових значень; все решта за відсутності radix розбирається як десяткове значення. Щоб розбирати такі префікси, можна скористатися Number() або BigInt().

Якщо основа числення – 16, то parseInt() дозволяє (хоча не вимагає), аби рядок починався з 0x чи 0X після необов'язкового символу знаку (+ або -).

Якщо значення основи (за потреби приведене) не лежить в діапазоні [2, 36] (включно), то parseInt повертає NaN.

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

Функція parseInt розуміє виключно два знаки: + для додатних чисел і - для від'ємних. Розбір знаку виконується як перший крок після усування пробілів. Якщо знаків не знайдено, то алгоритм переходить до наступного кроку; інакше – прибирає знаки та виконує розбір числа в решті рядка.

Якщо parseInt зустрічає символ, що не є цифрою за заданою основою radix, вона ігнорує його та всі символи після нього та повертає ціле число, розібране до цього. Наприклад, хоч рядок 1e3 технічно кодує ціле число (і буде коректно розібраний parseFloat() як ціле число 1000), parseInt("1e3", 10) поверне 1, тому що e не є дійсною цифрою при основі числення 10. Через те, що . також не є цифрою, повернене значення завжди буде цілим числом.

Якщо перший символ не може бути перетворений на число у використовуваній системі числення, то parseInt повертає NaN. Пробіли на початку рядка – дозволені.

Для арифметичних потреб значення NaN не вважається числом жодної системи числення. Щоб визначити, чи є результатом parseInt NaN, можна викликати функцію Number.isNaN. Якщо 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); // Узагалі не число
parseInt("546", 2); // Цифри, що відмінні від 0 і 1, недійсні у двійковій системі

Усі наступні приклади повернуть -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: Рядок "null" – це 1112745 за основою 36
parseInt(undefined, 36); // 86464843759093: Рядок "undefined" – це 86464843759093 за основою 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); // Дуже велике число стає 4
parseInt(0.00000000000434, 10); // Дуже мале число стає 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()