---
title: parseInt()
slug: Web/JavaScript/Reference/Global_Objects/parseInt
tags:
  - JavaScript
  - Довідка
  - метод
translation_of: Web/JavaScript/Reference/Global_Objects/parseInt
---
<div>{{jsSidebar("Objects")}}</div>

<p>Функція <code><strong>parseInt()</strong></code> розбирає рядковий аргумент і повертає число з вказаною <a href="https://en.wikipedia.org/wiki/Radix">основою</a> системи числення.</p>

<div>{{EmbedInteractiveExample("pages/js/globalprops-parseint.html")}}</div>

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

<h2 id="Синтаксис">Синтаксис</h2>

<pre class="syntaxbox notranslate">parseInt(<em>string</em>, <em>radix</em>);</pre>

<h3 id="Параметри">Параметри</h3>

<dl>
 <dt><code>string</code></dt>
 <dd>Значення, яке розбиратиметься. Якщо цей аргумент не є рядком, тоді він буде перетворений на рядок абстрактною операцією <code><a href="https://tc39.es/ecma262/#sec-tostring">ToString</a></code>. Пробільні символи на початку аргументу ігноруються.</dd>
 <dt><code>radix</code>  {{optional_inline}}</dt>
 <dd>Ціле число між <code>2</code> і <code>36</code>, яке вказує <var>основу</var> (в математичних системах числення) значення <em><code>string</code></em>. Будьте обережні — воно <strong><em>не</em></strong> дорівнює за замовчуванням <code>10</code>!</dd>
 <dd class="blockIndicator warning"><a href="#Опис">Наведений нижче опис</a> поясює більш детально, що відбувається, якщо значення <em><code>radix</code></em> не надане.</dd>
</dl>

<h3 id="Повернене_значення">Повернене значення</h3>

<p>Число, отримане з наданого рядка <em><code>string</code></em>.</p>

<p>Або {{jsxref("NaN")}}, коли</p>

<ul>
 <li>значення <code>radix</code> менше за <code>2</code> чи більше за <code>36</code>, або</li>
 <li>перший непробільний символ не може бути перетворений на число.</li>
</ul>

<h2 id="Опис">Опис</h2>

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

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

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

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

<p>Оскільки деякі числа використовують символ <code>e</code> у своєму рядковому представленні (наприклад, <strong><code>6.022e23</code></strong> для 6.022 × 10<sup>23</sup>), використання <code>parseInt</code> для обрізання чисел призведе до неочікуваних результатів при використанні на дуже великих чи дуже малих числах. <code>parseInt</code> не слід використовувати як заміну {{jsxref("Math.floor()")}}.</p>

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

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

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

<p>Для арифметичних цілей, значення <code>NaN</code> не є числом в жодній системі числення. Ви можете викликати функцію {{jsxref("isNaN")}}, щоб визначити, чи результат <code>parseInt</code> дорівнює <code>NaN</code>. Якщо <code>NaN</code> передається у арифметичні операції, результатом операції також буде <code>NaN</code>.</p>

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

<div class="blockIndicator warning">
<p><strong>Застереження щодо {{jsxref("BigInt")}}</strong>: <code>parseInt</code> перетворює {{jsxref("BigInt")}} на {{jsxref("Число", "Number")}} та в процесі втрачає точність, оскільки нечислові значення в кінці аргументу, в тому числі "n", відкидаються.</p>
</div>

<h3 id="Вісімкові_інтерпретації_без_значення_radix">Вісімкові інтерпретації без значення radix</h3>

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

<pre class="brush: js notranslate">parseInt('0e0')  // 0
parseInt('08')   // 0, бо '8' не вісімкова цифра.</pre>

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

<p>ECMAScript 5 зазначає:</p>

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

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

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

<h3 id="Більш_строга_функція_розбору">Більш строга функція розбору</h3>

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

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

<pre class="brush: js notranslate">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</pre>

<h2 id="Приклади">Приклади</h2>

<h3 id="Використання_parseInt">Використання parseInt</h3>

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

<pre class="brush: js notranslate">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)
</pre>

<p>Усі наступні приклади повертають <code>NaN</code>:</p>

<pre class="brush: js notranslate">parseInt('Привіт', 8) // Зовсім не число
parseInt('546', 2)    // Числа, інші, ніж 0 чи 1, недозволені у двійковій системі
</pre>

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

<pre class="brush: js notranslate">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)
</pre>

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

<pre class="brush: js notranslate">parseInt(4.7, 10)
parseInt(4.7 * 1e22, 10) // Дуже велике число стає 4
parseInt(0.00000000000434, 10) // Дуже маленьке число стає 4
</pre>

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

<pre class="brush: js notranslate">parseInt(0.0000001,10);
parseInt(0.000000123,10);
parseInt(1e-7,10);
parseInt(1000000000000000000000,10);
parseInt(123000000000000000000000,10);
parseInt(1e+21,10);</pre>

<p>Наступний приклад повертає <code>224</code>:</p>

<pre class="brush: js notranslate">parseInt('0e0', 16)
</pre>

<p>Значення {{jsxref("BigInt")}} втрачають точність:</p>

<pre class="brush: js notranslate">parseInt(900719925474099267n)
// 900719925474099300</pre>

<p>parseInt не працює з <a href="/uk/docs/Web/JavaScript/Reference/Lexical_grammar#Числові_роздільники">числовими роздільниками</a>:</p>

<pre class="brush: js notranslate">parseInt('123_456');
// 123
</pre>

<h2 id="Специфікації">Специфікації</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Специфікація</th>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-parseint-string-radix', 'parseInt')}}</td>
  </tr>
 </tbody>
</table>

<h2 id="Сумісність_з_веб-переглядачами">Сумісність з веб-переглядачами</h2>



<p>{{Compat("javascript.builtins.parseInt")}}</p>

<h2 id="Див._також">Див. також</h2>

<ul>
 <li>{{jsxref("Global_Objects/parseFloat", "parseFloat()")}}</li>
 <li>{{jsxref("Number.parseFloat()")}}</li>
 <li>{{jsxref("Number.parseInt()")}}</li>
 <li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li>
 <li>{{jsxref("Number.toString()")}}</li>
 <li>{{jsxref("Object.valueOf")}}</li>
</ul>