parseInt()

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

Синтаксис

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 × 1023), використання 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).

Застереження щодо BigIntparseInt перетворює BigInt на Number та в процесі втрачає точність, оскільки нечислові значення в кінці аргументу, в тому числі "n", відкидаються.

Вісімкові інтерпретації без значення 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

Приклади

Використання parseInt

Усі наступні приклади повертають 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

Специфікації

Специфікація
ECMAScript (ECMA-262)
The definition of 'parseInt' in that specification.

Сумісність з веб-переглядачами

Update compatibility data on GitHub
DesktopMobileServer
ChromeEdgeFirefoxInternet ExplorerOperaSafariAndroid webviewChrome for AndroidFirefox for AndroidOpera for AndroidSafari on iOSSamsung InternetNode.js
parseIntChrome Full support 1Edge Full support 12Firefox Full support 1IE Full support 3Opera Full support 3Safari Full support 1WebView Android Full support 1Chrome Android Full support 18Firefox Android Full support 4Opera Android Full support 10.1Safari iOS Full support 1Samsung Internet Android Full support 1.0nodejs Full support 0.1.100
Parses leading-zero strings are decimal, not octalChrome Full support 23Edge Full support 12Firefox Full support 21IE Full support 9Opera Full support 15Safari Full support 6WebView Android Full support 4.4Chrome Android Full support 25Firefox Android Full support 21Opera Android Full support 14Safari iOS Full support 6Samsung Internet Android Full support 1.5nodejs Full support 0.10

Legend

Full support  
Full support

Див. також