---
sidebar_position: 2
---

# Числа
В современном JavaScript существует два типа чисел:
1. Обычные числа в JavaScript хранятся в 64-битном формате IEEE-754, который также называют «числа с плавающей точкой двойной точности» (double precision floating point numbers).
2. BigInt числа дают возможность работать с целыми числами произвольной длины. Они нужны достаточно редко и используются в случаях, когда необходимо работать со значениями более чем (253-1) или менее чем -(253-1).

### Способы записи числа

```js
let billion = 1000000000;
let billion = 1_000_000_000
let billion = 1e9;
```
```js
let mcs = 0.000001;
let ms = 1e-6; // шесть нулей слева от 1
let a = 0b11111111; // двоичная (бинарная) форма записи числа 255
let b = 0o377; // восьмеричная форма записи числа 255
```
### toString(base)
**base** может варьироваться от 2 до 36 (по умолчанию 10).
```js
alert( (255).toString(16) );  // ff
alert( (255).toString(2) );   // 11111111
alert( 123456..toString(36) ); // 2n9c
```
Две точки в 123456..toString(36) это не опечатка. Если нам надо вызвать метод непосредственно на числе, как toString в примере выше, то нам надо поставить две точки .. после числа.

### Округление
- **Math.floor** \
    Округление в меньшую сторону: 3.1 становится 3, а -1.1 — -2.
- **Math.ceil** \
    Округление в большую сторону: 3.1 становится 4, а -1.1 — -1.
- **Math.round** \
    Округление до ближайшего целого: 3.1 становится 3, 3.6 — 4, а -1.1 — -1.
- **Math.trunc** (не поддерживается в Internet Explorer) \
    Производит удаление дробной части без округления: 3.1 становится 3, а -1.1 — -1.
- Метод **toFixed(n)** \
    округляет число до n знаков после запятой и возвращает строковое представление результата.\
    ``` alert( (12.34).toFixed(1) ); // "12.3" ```

### Неточные вычисления
Внутри JavaScript число представлено в виде 64-битного формата IEEE-754. Для хранения числа используется 64 бита: 52 из них используется для хранения цифр, 11 для хранения положения десятичной точки и один бит отведён на хранение знака.

```js
alert( 1e500 ); // Infinity
```
Наиболее часто встречающаяся ошибка при работе с числами в JavaScript – это потеря точности.
```js
alert( 0.1 + 0.2 ); // 0.30000000000000004
```
И когда мы суммируем 2 числа, их «неточности» тоже суммируются. Наиболее надёжный способ — это округлить результат используя метод toFixed(n):
```js
alert( +(0.1 + 0.2).toFixed(2) ); // 0.3
```

### Проверка: isFinite и isNaN
- Infinity (и -Infinity) — особенное численное значение, которое ведёт себя в точности как математическая бесконечность ∞.
- NaN представляет ошибку.

**isNaN(value)** преобразует значение в число и проверяет является ли оно NaN:
```js
alert( isNaN(NaN) ); // true
alert( isNaN("str") ); // true
alert( NaN === NaN ); // false
```

**isFinite(value)** преобразует аргумент в число и возвращает true, если оно является обычным числом, т.е. не NaN/Infinity/-Infinity
Иногда isFinite используется для проверки, содержится ли в строке число:
```js
alert( isFinite("15") ); // true
alert( isFinite("str") ); // false, потому что специальное значение: NaN
alert( isFinite(Infinity) ); // false, потому что специальное значение: Infinity

// вернёт true всегда, кроме ситуаций, когда аргумент - Infinity/-Infinity или не число
alert( isFinite(num) );
```
Методы **Number.isNaN** и **Number.isFinite** – это более «строгие» версии функций isNaN и isFinite. Они не преобразуют аргумент в число, а наоборот – первым делом проверяют, является ли аргумент числом (принадлежит ли он к типу number).
Number.isNaN(value) возвращает true только в том случае, если аргумент принадлежит к типу number и является NaN. Во всех остальных случаях возвращает false.
```js
alert( Number.isNaN(NaN) ); // true
alert( Number.isNaN("str" / 2) ); // true

// Обратите внимание на разный результат:
alert( Number.isNaN("str") ); // false, так как "str" является строкой, а не числом
alert( isNaN("str") ); // true, так как isNaN сначала преобразует строку "str" в число и в результате преобразования получает NaN
```
Number.isFinite(value) возвращает true только в том случае, если аргумент принадлежит к типу number и не является NaN/Infinity/-Infinity. Во всех остальных случаях возвращает false.
```js
alert( Number.isFinite(123) ); // true
alert( Number.isFinite(Infinity) ); // false
alert( Number.isFinite(2 / 0) ); // false

// Обратите внимание на разный результат:
alert( Number.isFinite("123") ); // false, так как "123" является строкой, а не числом
alert( isFinite("123") ); // true, так как isFinite сначала преобразует строку "123" в число 123
```
Не стоит считать Number.isNaN и Number.isFinite более «корректными» версиями функций isNaN и isFinite. Это дополняющие друг-друга инструменты для разных задач.

💥 **Сравнение Object.is**
Существует специальный метод Object.is, который сравнивает значения примерно как ===, но более надёжен в двух особых ситуациях:

Работает с NaN: Object.is(NaN, NaN) === true, здесь он хорош.
Значения 0 и -0 разные: Object.is(0, -0) === false, это редко используется, но технически эти значения разные.
Во всех других случаях Object.is(a, b) идентичен a === b.

Этот способ сравнения часто используется в спецификации JavaScript. Когда внутреннему алгоритму необходимо сравнить 2 значения на предмет точного совпадения, он использует Object.is

### parseInt и parseFloat
Для явного преобразования к числу можно использовать + или Number(). Если строка не является в точности числом, то результат будет NaN, пробелы в начале строки и в конце игнорируются.
Функция parseInt() имеет необязательный второй параметр. Он определяет систему счисления,
```js
alert( parseInt('100px') ); // 100
alert( parseFloat('12.5em') ); // 12.5
alert( +"100px" ); // NaN
alert( parseInt('a123') ); // NaN
```

### Другие математические функции
В JavaScript встроен объект **Math**, который содержит различные математические функции и константы.

🚀 **Источник: [https://learn.javascript.ru/number](https://learn.javascript.ru/number)**