parseInt()

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

код для цього інтерактивного прикладу зберігається  в репозиторії  GitHub .Якщо ви хочете внести свій внесок у проект інтерактивних прикладів, будь-ласка клонуйте https://github.com/mdn/interactive-examples і присилайте нам pull request.

parseInt(string, radix);

string

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

radix  Optional

Ціле число між 2 і 36, яке вказує основу (в математичних системах числення) значення string. Будьте обережні — воно не дорівнює за замовчуванням 10!

Наведений нижче опис поясює більш детально, що відбувається, якщо значення radix не надане.

Число, отримане з наданого рядка string.

Або NaN, коли

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

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

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

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

Якщо метод parseInt зустрічає символ, який не є числом у вказаній системі radix, він ігнорує цей символ та усі наступні символи та повертає ціле число, розібране до цієї позиції. parseInt обрізає числа до цілих значень. Пробільні символи попереду та в кінці є дозволеними.

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

Якщо radix дорівнює undefined, 0 або його значення невизначене, JavaScript припускає наступне:

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

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

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

Щоб перетворити число на його рядковий літерал у певній системі числення, використовуйте вашеЧисло.toString(radix).

Хоча це не схвалюється у ECMAScript 3 та заборонене у ECMAScript 5, багато реалізацій інтерпретують числові рядки, що починаються з 0, як вісімкові. Наступне може перетворитись на вісімковий результат, а може й на десятковий. Завжди вказуйте radix, щоб запобігти цій ненадійній поведінці.

parseInt('0e0')  // 0
parseInt('08')   // 0, бо '8' не вісімкова цифра.

Специфікація ECMAScript 5 функції parseInt більше не дозволяє реалізаціям сприймати рядки, що починаються з символу 0, як вісімкові значення.

ECMAScript 5 зазначає:

Функція parseInt створює цілочисельне значення, продиктоване інтерпретацією вмісту рядкового аргументу у відповідності до вказаної основи системи числення. Пробільний символ на початку рядка ігнорується. Якщо основа дорівнює undefined або 0, вона вважається рівною 10, окрім випадків, коли число починається з пар символів 0x або 0X, в такому випадку основа вважається рівною 16.

Це відрізняється від ECMAScript 3, де вісімкова інтерпретація просто не схвалюється (але дозволена).

У багатьох реалізаціях ця поведінка не адаптована станом на 2013 рік. І, оскільки старші веб-переглядачі мають підтримуватись, завжди вказуйте значення radix.

Іноді корисно мати більш строгий спросіб розбору цілих чисел.

Регулярні вирази можуть стати в пригоді:

function filterInt(value) {
  if (/^[-+]?(\d+|Infinity)$/.test(value)) {
    return Number(value)
  } else {
    return NaN
  }
}

console.log(filterInt('421'))                // 421
console.log(filterInt('-421'))               // -421
console.log(filterInt('+421'))               // 421
console.log(filterInt('Infinity'))           // Infinity
console.log(filterInt('421e+0'))             // NaN
console.log(filterInt('421hop'))             // NaN
console.log(filterInt('hop1.61803398875'))   // NaN
console.log(filterInt('1.61803398875'))      // NaN

Усі наступні приклади повертають 15:

parseInt('0xF', 16)
parseInt('F', 16)
parseInt('17', 8)
parseInt(021, 8)
parseInt('015', 10)   // але `parseInt(015, 10)` поверне 13
parseInt(15.99, 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('Привіт', 8) // Зовсім не число
parseInt('546', 2)    // Числа, інші, ніж 0 чи 1, недозволені у двійковій системі

Усі наступні приклади повертають -15:

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

Усі наступні приклади повертають 4:

parseInt(4.7, 10)
parseInt(4.7 * 1e22, 10) // Дуже велике число стає 4
parseInt(0.00000000000434, 10) // Дуже маленьке число стає 4

Якщо число більше за 1e+21 (включно) або менше за 1e-7 (включно), метод поверне 1. (при використанні основи 10).

parseInt(0.0000001,10);
parseInt(0.000000123,10);
parseInt(1e-7,10);
parseInt(1000000000000000000000,10);
parseInt(123000000000000000000000,10);
parseInt(1e+21,10);

Наступний приклад повертає 224:

parseInt('0e0', 16)

Значення BigInt втрачають точність:

parseInt(900719925474099267n)
// 900719925474099300

parseInt не працює з числовими роздільниками:

parseInt('123_456');
// 123

• parseFloat()
• Number.parseFloat()
• Number.parseInt()
• isNaN()
• Number.toString()
• Object.valueOf