parseInt()
==========

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

Интерактивный пример
--------------------

Синтаксис
---------
```

parseInt(string, radix);
```

### Параметры

`string`

Значение, которое необходимо проинтерпретировать. Если значение параметра `string` не принадлежит строковому типу, оно преобразуется в него (с помощью абстрактной операции `ToString`). Пробелы в начале строки не учитываются.


`radix`

Целое число в диапазоне между 2 и 36, представляющее собой основание системы счисления числовой строки `string`, описанной выше. В основном пользователи используют десятичную систему счисления и указывают 10. **Всегда указывайте этот параметр,** чтобы исключить ошибки считывания и гарантировать корректность исполнения и предсказуемость результата. Когда основание системы счисления не указано, разные реализации могут возвращать разные результаты.

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

Целое число, полученное парсингом (разбором и интерпретацией) переданной строки. Если первый символ не получилось сконвертировать в число, то возвращается `NaN`.

Описание
--------

Функция `parseInt` преобразует первый переданный ей аргумент в строковый тип, интерпретирует его и возвращает целое число или значение `NaN`. Результат (если не `NaN`) является целым числом и представляет собой первый аргумент (`string`), рассматривающийся как число в указанной системе счисления (`radix`). Например, основание 10 указывает на преобразование из десятичного числа, 8 - восьмеричного, 16 - шестнадцатеричного и так далее. Если основание больше `10`, то для обозначения цифр больше `9` используются буквы. Например, для шестнадцатеричных чисел (основание 16) используются буквы от `A` до `F`.

Если функция `parseInt` встречает символ, не являющийся числом в указанной системе счисления, она пропускает этот и все последующие символы (даже, если они подходящие) и возвращает целое число, преобразованное из части строки, предшествовавшей этому символу. `parseInt` отсекает дробную часть числа. Пробелы в начале и конце строки разрешены.

Так как некоторые числа включают символ `e` в своём строковом представлении (например, **`6.022e23`**), то использование `parseInt` для усечения числовых значений может дать неожиданные результаты, когда используются очень малые или очень большие величины. `parseInt` не должна использоваться как замена для `Math.floor()`.

Если основание системы счисления имеет значение `undefined` (не определено) или равно 0 (или не указано), то JavaScript по умолчанию предполагает следующее:

* Если значение входного параметра `string` начинается с "`0x`" или "`0X`", *за основание системы счисления принимается 16, и интерпретации подвергается оставшаяся часть строки.*
* Если значение входного параметра `string` начинается с "0", *за основание системы счисления принимается либо 8, либо 10, в зависимости от конкретной реализации.* В спецификации ECMAScript 5 прописано использование 10 (десятичная система), но это поддерживается ещё не всеми браузерами, поэтому необходимо **всегда указывать основание системы счисления при использовании функции** **`parseInt`**.
* Если значение входного параметра `string` начинается с любого другого символа, система счисления считается десятичной (основание 10).

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

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

Для преобразования числа в строку в указанной системе счисления, используйте `intValue.toString(radix)`.

Примеры
-------

### Пример: Использование `parseInt`

Все следующие примеры возвращают **`15`**:


```js
parseInt(" 0xF", 16);
parseInt(" F", 16);
parseInt("17", 8);
parseInt(021, 8);
parseInt("015", 10); //parseInt(015, 10); вернёт 15
parseInt(15.99, 10);
parseInt("FXX123", 16);
parseInt("1111", 2);
parseInt("15\*3", 10);
parseInt("15e2", 10);
parseInt("15px", 10);
parseInt("12", 13);
```


Все следующие примеры возвращают **`NaN`**:


```js
parseInt("Hello", 8); // Не является числом
parseInt("546", 2); // Неверное число в двоичной системе счисления
```


Все следующие примеры возвращают **`-15`**:


```js
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`**:


```js
parseInt(4.7, 10);
parseInt(4.7 \* 1e22, 10); // Очень большие числа становятся 4
parseInt(0.00000000000434, 10); // Очень маленькие числа становятся 4
```


Следующий пример возвращает **`224`**:


```js
parseInt("0e0", 16);
```

Восьмеричная интерпретация без указания системы счисления
---------------------------------------------------------

Хотя это не поощряется в спецификацией ECMAScript 3 и запрещено в ECMAScript 5, многие реализации интерпретируют числовую строку, начинающуюся с `0`, как восьмеричную. Следующий пример может иметь как восьмеричный, так и десятичный результат. **Чтобы избежать непредвиденного результата, всегда указывайте основание системы счисления.**


```js
parseInt("0e0"); // 0
parseInt("08"); // 0, '8' не является цифрой в восьмеричной системе.
```

### ECMAScript 5 устраняет восьмеричную интерпретацию

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

Функция `parseInt` производит целочисленное значение в результате интерпретации содержимого строкового аргумента в соответствии с указанным основанием системы счисления. Пробел в начале строки не учитывается. Если основание системы счисления не определено или равно `0`, оно считается равным `10`, за исключением случаев, когда строка начинается с пар символов `0x` или `0X`: тогда за основание принимается 16. Если основанием системы счисления указано `16`, число также может начинаться с пар символов `0x` или `0X`.

В этом ECMAScript 5 расходится со спецификацией ECMAScript 3, в которой восьмеричная интерпретация не поощрялась, но и не была запрещена.

Поскольку на момент 2013 года описанное выше поведение было применено не во всех реализациях, а поддержка старых браузеров является необходимой, **всегда указывайте основание системы счисления.**

Более строгая функция интерпретации
-----------------------------------

Иногда необходим более строгий способ интерпретации целочисленных значений. В этом могут помочь регулярные выражения:


```js
var filterInt = function (value) {
  if (/^(\-|\+)?([0-9]+|Infinity)$/.test(value)) return Number(value);
  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
```

Спецификация
------------

| Specification |
| --- |
| ECMAScript Language Specification # sec-parseint-string-radix |

Совместимость с браузерами
--------------------------

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

Смотрите также
--------------

* `parseFloat()`
* `Number.parseFloat()`
* `Number.parseInt()`
* `isNaN()`
* `Number.toString()`
* `Object.valueOf`