Javascript nan ошибка

alert( 0xFF ); // 255 в шестнадцатиричной системе

// еще пример научной формы: 3 с 5 нулями
alert( 3e5 ); // 300000

// здесь 3 сдвинуто 5 раз вправо, за десятичную точку.
alert( 3e-5 ); // 0.00003  <-- 5 нулей, включая начальный ноль

alert( 1 / 0 ); // Infinity
alert( 12345 / 0 ); // Infinity

alert( Infinity > 1234567890 ); // true
alert( Infinity + 5 == Infinity ); // true

alert( -1 / 0 ); // -Infinity

alert( 1e500 ); // Infinity

var n = 0 / 0;

if (n !== n) alert( 'n = NaN!' );

```smart header="Математические операции в JS безопасны"
Никакие математические операции в JavaScript не могут привести к ошибке или "обрушить" программу.

В худшем случае результат будет `NaN`.
```

## isFinite(n)

Итак, в JavaScript есть обычные числа и три специальных числовых значения: `NaN`, `Infinity` и `-Infinity`.

Тот факт, что они, хоть и особые, но числа, демонстрируется работой оператора `+`:

```js run
var value = prompt("Введите Infinity", 'Infinity');

*!*
var number = +value;
*/!*

alert( number ); // Infinity, плюс преобразовал строку "Infinity" к такому "числу"
```

Обычно если мы хотим от посетителя получить число, то `Infinity` или `NaN` нам не подходят. Для того чтобы отличить "обычные" числа от таких специальных значений, существует функция `isFinite`.

**Функция `isFinite(n)` преобразует аргумент к числу и возвращает `true`, если это не `NaN/Infinity/-Infinity`:**

```js run
alert( isFinite(1) ); // true
alert( isFinite(Infinity) ); // false
alert( isFinite(NaN) ); // false
```

## Преобразование к числу

Большинство арифметических операций и математических функций преобразуют значение в число автоматически.

Для того чтобы сделать это явно, обычно перед значением ставят унарный плюс `'+'`:

```js run
var s = "12.34";
alert( +s ); // 12.34
```

При этом, если строка не является в точности числом, то результат будет `NaN`:

```js run
alert( +"12test" ); // NaN
```

Единственное исключение -- пробельные символы в начале и в конце строки, которые игнорируются:

```js run
alert( +"  -12" ); // -12
alert( +" n34  n" ); // 34, перевод строки n является пробельным символом
alert( +"" ); // 0, пустая строка становится нулем
alert( +"1 2" ); // NaN, пробел посередине числа - ошибка
```

Аналогичным образом происходит преобразование и в других математических операторах и функциях:

```js run
alert( '12.34' / "-2" ); // -6.17
```

## Мягкое преобразование: parseInt и parseFloat

В мире HTML/CSS многие значения не являются в точности числами. Например метрики CSS: `10pt` или `-12px`.

Оператор `'+'` для таких значений возвратит `NaN`:

```js run
alert(+"12px") // NaN
```

Для удобного чтения таких значений существует функция [parseInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt):

```js run
alert( parseInt('12px') ); // 12
```

**Функция `parseInt` и ее аналог `parseFloat` преобразуют строку символ за символом, пока это возможно.**

При возникновении ошибки возвращается число, которое получилось. Функция `parseInt` читает из строки целое число, а `parseFloat` -- дробное.

```js run
alert( parseInt('12px') ) // 12, ошибка на символе 'p'
alert( parseFloat('12.3.4') ) // 12.3, ошибка на второй точке
```

Конечно, существуют ситуации, когда `parseInt/parseFloat` возвращают `NaN`. Это происходит при ошибке на первом же символе:

```js run
alert( parseInt('a123') ); // NaN
```

Функция `parseInt` также позволяет указать систему счисления, то есть считывать числа, заданные в шестнадцатиричной и других системах счисления:

```js run
alert( parseInt('FF', 16) ); // 255
```

## Проверка на число

Для проверки строки на число можно использовать функцию `isNaN(str)`.

Она преобразует строку в число аналогично `+`, а затем вернёт `true`, если это `NaN`, то есть если преобразование не удалось:

```js run
var x = prompt("Введите значение", "-11.5");

if (isNaN(x)) {
  alert( "Строка преобразовалась в NaN. Не число" );
} else {
  alert( "Число" );
}
```

Однако, у такой проверки есть две особенности:

1. Пустая строка и строка из пробельных символов преобразуются к `0`, поэтому считаются числами.
2. Если применить такую проверку не к строке, то могут быть сюрпризы, в частности `isNaN` посчитает числами значения `false, true, null`, так как они хотя и не числа, но преобразуются к ним.

```js run
alert( isNaN(null) ); //  false - не NaN, т.е. "число"
alert( isNaN("n  n") ); //  false - не NaN, т.е. "число"
```

Если такое поведение допустимо, то `isNaN` -- приемлемый вариант.

Если же нужна действительно точная проверка на число, которая не считает числом строку из пробелов, логические и специальные значения, а также отсекает `Infinity` -- используйте следующую функцию `isNumeric`:

```js
function isNumeric(n) {
  return !isNaN(parseFloat(n)) && isFinite(n);
}
```

Разберёмся, как она работает. Начнём справа.

- Функция `isFinite(n)` преобразует аргумент к числу и возвращает `true`, если это не `Infinity/-Infinity/NaN`.

    Таким образом, правая часть отсеет заведомо не-числа, но оставит такие значения как `true/false/null` и пустую строку `''`, так как они корректно преобразуются в числа.
- Для их проверки нужна левая часть. Вызов `parseFloat(true/false/null/'')` вернёт `NaN` для этих значений.

    Так устроена функция `parseFloat`: она преобразует аргумент к строке, то есть `true/false/null` становятся `"true"/"false"/"null"`, а затем считывает из неё число, при этом пустая строка даёт `NaN`.

В результате отсеивается всё, кроме строк-чисел и обычных чисел.

## toString(система счисления)

Как показано выше, числа можно записывать не только в 10-ричной, но и в 16-ричной системе. Но бывает и противоположная задача: получить 16-ричное представление числа. Для этого используется метод `toString(основание системы)`, например:

```js run
var n = 255;

alert( n.toString(16) ); // ff
```

В частности, это используют для работы с цветовыми значениями в браузере, вида `#AABBCC`.

Основание может быть любым от `2` до `36`.

- Основание `2` бывает полезно для отладки побитовых операций:

    ```js run
    var n = 4;
    alert( n.toString(2) ); // 100
    ```
- Основание `36` (по количеству букв в английском алфавите -- 26, вместе с цифрами, которых 10) используется для того, чтобы "кодировать" число в виде буквенно-цифровой строки. В этой системе счисления сначала используются цифры, а затем буквы от `a` до `z`:

    ```js run
    var n = 1234567890;
    alert( n.toString(36) ); // kf12oi
    ```

    При помощи такого кодирования можно "укоротить" длинный цифровой идентификатор, например чтобы выдать его в качестве URL.

## Округление

Одна из самых частых операций с числом -- округление. В JavaScript существуют целых 3 функции для этого.

`Math.floor`
: Округляет вниз

`Math.ceil`
: Округляет вверх

`Math.round`
: Округляет до ближайшего целого

```js run no-beautify
alert( Math.floor(3.1) );  // 3
alert( Math.ceil(3.1) );   // 4
alert( Math.round(3.1) );  // 3
```

````smart header="Округление битовыми операторами"
[Битовые операторы](/bitwise-operators) делают любое число 32-битным целым, обрезая десятичную часть.

В результате побитовая операция, которая не изменяет число, например, двойное битовое НЕ -- округляет его:

```js run
alert( ~~12.3 ); // 12
```

Любая побитовая операция такого рода подойдет, например XOR (исключающее ИЛИ, `"^"`) с нулем:

```js run
alert( 12.3 ^ 0 ); // 12
alert( 1.2 + 1.3 ^ 0 ); // 2, приоритет ^ меньше, чем +
```

Это удобно в первую очередь тем, что легко читается и не заставляет ставить дополнительные скобки как `Math.floor(...)`:

```js
var x = a * b / c ^ 0; // читается как "a * b / c и округлить"
```

var n = 3.456;
alert( Math.round(n * 100) / 100 ); // 3.456 -> 345.6 -> 346 -> 3.46

var n = 12.34;
alert( n.toFixed(1) ); // "12.3"

var n = 12.36;
alert( n.toFixed(1) ); // "12.4"

var n = 12.34;
alert( n.toFixed(5) ); // "12.34000", добавлены нули до 5 знаков после запятой

var n = 12.34;
alert( +n.toFixed(5) ); // 12.34

var price = 6.35;

alert( price.toFixed(1) ); // 6.3
alert( Math.round(price * 10) / 10 ); // 6.4

## Неточные вычисления

Запустите этот пример:

```js run
alert( 0.1 + 0.2 == 0.3 );
```

Запустили? Если нет -- все же сделайте это.

Ок, вы запустили его. Он вывел `false`. Результат несколько странный, не так ли? Возможно, ошибка в браузере? Поменяйте браузер, запустите еще раз.

Хорошо, теперь мы можем быть уверены: `0.1 + 0.2` это не `0.3`. Но тогда что же это?

```js run
alert( 0.1 + 0.2 ); // 0.30000000000000004
```

Как видите, произошла небольшая вычислительная ошибка, результат сложения `0.1 + 0.2` немного больше, чем `0.3`.

```js run
alert( 0.1 + 0.2 > 0.3 ); // true
```

Всё дело в том, что в стандарте IEEE 754 на число выделяется ровно 8 байт(=64 бита), не больше и не меньше.

Число `0.1 (одна десятая)` записывается просто в десятичном формате. Но в двоичной системе счисления это бесконечная дробь, так как единица на десять в двоичной системе так просто не делится. Также бесконечной дробью является `0.2 (=2/10)`.

Двоичное значение бесконечных дробей хранится только до определенного знака, поэтому возникает неточность. Её даже можно увидеть:

```js run
alert( 0.1.toFixed(20) ); // 0.10000000000000000555
```

Когда мы складываем `0.1` и `0.2`, то две неточности складываются, получаем незначительную, но всё же ошибку в вычислениях.

Конечно, это не означает, что точные вычисления для таких чисел невозможны. Они возможны. И даже необходимы.

Например, есть два способа сложить `0.1` и `0.2`:

1. Сделать их целыми, сложить, а потом поделить:

    ```js run
    alert( (0.1 * 10 + 0.2 * 10) / 10 ); // 0.3
    ```

    Это работает, так как числа `0.1*10 = 1` и `0.2*10 = 2` могут быть точно представлены в двоичной системе.
2. Сложить, а затем округлить до разумного знака после запятой. Округления до 10-го знака обычно бывает достаточно, чтобы отсечь ошибку вычислений:

    ```js run
    var result = 0.1 + 0.2;
    alert( +result.toFixed(10) ); // 0.3
    ```

````smart header="Забавный пример"
Привет! Я -- число, растущее само по себе!

```js run
alert( 9999999999999999 ); // выведет 10000000000000000
```

Причина та же -- потеря точности.

Из `64` бит, отведённых на число, сами цифры числа занимают до `52` бит, остальные `11` бит хранят позицию десятичной точки и один бит -- знак. Так что если `52` бит не хватает на цифры, то при записи пропадут младшие разряды.

Интерпретатор не выдаст ошибку, но в результате получится "не совсем то число", что мы и видим в примере выше. Как говорится: "как смог, так записал".

var number = 123456789;

alert( number.toLocaleString() ); // 123 456 789