---
title: "Число"
description: "Тип данных для работы с числами."
url: "https://doka.guide/js/number/"
section: "JavaScript"
createdAt: "2021-10-12"
updatedAt: "2024-12-16"
authors: ["nlopin"]
contributors: ["anastasiayarosh"]
related: ["js/typecasting", "js/expressions-vs-statements", "tools/coordinates"]
source: "https://github.com/doka-guide/content/blob/main/js/number/index.md"
license: "CC BY-NC-SA 4.0"
---

# Число

## Кратко

Тип данных «число» (`number`) содержит числа с плавающей точкой в диапазоне от -(2<sup>53</sup> − 1) до 2<sup>53</sup> − 1, а также специальные значения `Infinity`, `-Infinity` и `NaN`.

Для этого типа данных определены стандартные арифметические операции сложения `+`, вычитания `-`, умножения `*`, деления `/`, взятия остатка от целочисленного деления `%`, [сравнения](/js/typecasting/#strogoe-i-nestrogoe-ravenstvo) `>`, `<`, `>=`, `<=`, `==`, `===`, `!=`, `!==`.

В JavaScript отсутствует отдельный тип данных для целых чисел, для целых чисел также используется тип `number`.

## Как пишется

Для записи чисел используются цифры, для разделения целой и десятичной части используется точка:

```js
const int = 4
const decimal = 0.101
const sameDecimal = .101
```

Можно использовать экспоненциальную запись. Например, один миллион в экспоненциальной записи:

```js
const scientific = 1e6
```

Числа так же могут быть представлены в [двоичном](https://ru.wikipedia.org/wiki/Двоичная_система_счисления), [восьмеричном](https://ru.wikipedia.org/wiki/Восьмеричная_система_счисления) или [шестнадцатеричном](https://ru.wikipedia.org/wiki/Шестнадцатеричная_система_счисления) виде. Такие числа начинаются с приставки `0b`, `0o`, `0x` соответственно. При выводе на экран они будут преобразованы в десятичную систему счисления:

```js
const binary = 0b11
console.log(binary)
// 3

const octal = 0o77
console.log(octal)
// 63

const hexadecimal = 0xFF
console.log(hexadecimal)
// 255
```

## Как понять

### Число с плавающей точкой

Число в JavaScript представлено в виде 64-битного формата [IEEE-754](https://ru.wikipedia.org/wiki/IEEE_754-1985). Формат хранит произвольное число в виде трёх значений: 1 бит на знак числа, 52 бита значения числа и ещё 11 бит местоположения точки. С таким подходом можно эффективно хранить значения в большом диапазоне от -(2<sup>53</sup> − 1) до 2<sup>53</sup> − 1.

Из-за того, что положение точки в числе хранится отдельным значением, формат и называется числом с плавающей точкой (floating point number).

Проблема этого представления в том, что оно не может представить числа абсолютно точно, а только с некоторой погрешностью.

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

В десятичной системе счисления есть числа, которые не могут быть записаны точно. Например, треть ¹⁄₃ записывается как бесконечная дробь 0.33(3).

Компьютер хранит данные в двоичном виде — наборе нулей и единиц. В этой системе счисления тоже есть дроби, которые не могут быть записаны точно. В этом случае формат округляет значение до ближайшего представимого. При арифметических операциях эти неточности складываются и приводят к эффектам, подобным этому:

```js
console.log(0.2 + 0.7)
// 0.8999999999999999
```

Это не ошибка JavaScript, а фундаментальная особенность хранения дробных чисел в памяти компьютера, с ней нужно уметь работать. Для уменьшения эффекта используется комбинация подходов — использовать как можно меньше дробных значений, а когда этого невозможно избежать — округлять числа, тем самым сбрасывая накопившийся остаток.

Например, если ваша система работает с деньгами, то лучше хранить цены в копейках или центах. Это позволит избежать большого количества операций с дробями. Для вывода цен можно пользоваться методом `toFixed`, который округлит число до указанного разряда:

```js
const priceInCents = 15650
const discount = priceInCents * 0.33
const total = (priceInCents - discount) / 100
console.log(total.toFixed(2))
// 104.86
```

Похожую проблему можно наблюдать при сравнении очень маленьких и очень больших чисел. В таких случаях из-за округления точность теряется и различные числа компьютер представляет одинаковыми:

```js
const small = 0.11111111111111111
const smaller = 0.11111111111111110

console.log(small.toFixed(20))
// 0.11111111111111110494
console.log(smaller.toFixed(20))
// 0.11111111111111110494
console.log(small === smaller)
// true
```

### Специальные значения

Стандарт [IEEE-754](https://ru.wikipedia.org/wiki/IEEE_754-1985) определяет три специальных значения. Эти значения принадлежат типу `number`, но не работают, как обычные числа:

- бесконечность `Infinity`;
- минус бесконечность `-Infinity`;
- не число (not a number) `NaN`.

Бесконечности используются, чтобы определить результат некоторых арифметических операций. Например, деление на ноль в JavaScript вернёт бесконечность:

```js
console.log(5 / 0)
// Infinity

console.log(-3 / 0)
// -Infinity
```

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

```js
console.log(1e999)
// Infinity
```

Значение `NaN` используется, чтобы сообщить об операции, результатом которой оказалось не число. В JavaScript существует пять операций, которые могут вернуть `NaN`:

- ошибка парсинга числа (например, при попытке превратить строку в число [`parseInt('привет')`](/js/parseint/));
- результат математической операции не находится в поле действительных чисел (например, взятие корня от -1);
- один из операндов в арифметической операции — `NaN` (`5 + NaN`);
- результат арифметической операции не определён для переданных операндов (`undefined + undefined`);
- арифметическая операция со строкой, кроме сложения (`'привет' * 5`).

Согласно спецификации `NaN` _не равен самому себе_. Проверить, что в переменной хранится `NaN`, простым сравнением не получится:

```js
const result = NaN

console.log(result === NaN)
// false
```

Для проверки на `NaN` пользуйтесь функцией [`Number.isNaN()`](/js/number-is-nan/), которая возвращает `true` если переданное значение — `NaN`:

```js
const result = NaN

console.log(Number.isNaN(result))
// true
```

Если в математическом выражении есть `NaN`, в результате тоже получится `NaN`. Единственное исключение — возведение в нулевую степень. `NaN` ** 0 = 1.

Для проверки, что значение в переменной является конечным числом, а не специальным значением, используйте функцию [`Number.isFinite()`](/js/number-isfinite/). Она возвращает `true`, если переданный аргумент — число, кроме `Infinity`.

```js
const inf = Infinity
const nan = NaN
const num = 99999

console.log(Number.isFinite(inf))
// false
console.log(Number.isFinite(nan))
// false
console.log(Number.isFinite(num))
// true
```

### Операции с числами

С числами можно выполнять стандартные математические операции, для определения приоритета операций пользуются скобками:

```js
const a = 5
const b = 10

console.log(-a)
// -5
console.log(a + b)
// 15
console.log(a - b)
// -5
console.log(a / b)
// 0.5
console.log(a * b)
// 50

console.log((a + b) / 10)
// 1.5
```

Существует оператор взятия остатка от деления нацело `%`:

```js
console.log(5 % 2)
// 1, потому что 5 = 2 * 2 + 1
console.log(5 % 3)
// 2, потому что 5 = 1 * 3 + 2
console.log(5 % 5)
// 0, потому что 5 = 5 * 1 + 0
```

Возведения в степень `**`:

```js
console.log(2 ** 4)
// 16
```

Для округления, взятия корней и других математических операций в JavaScript существует отдельный модуль [`Math`](/js/math/).

Операторы сравнения возвращают [булево значение](/js/boolean/):

```js
console.log(5 > 10)
// false
console.log(5 >= 10)
// false
console.log(5 < 10)
// true
console.log(10 <= 10)
// true
console.log(5 == 10)
// false
console.log(5 === 10)
// false
console.log(5 != 10)
// true
console.log(5 !== 10)
// true
```

<aside>

☝️ Строгое `===` и нестрогое `==` сравнение работает одинаково, когда оба сравниваемых значения имеют тип «число». В других случаях [их поведение отличается](/js/typecasting/#strogoe-i-nestrogoe-ravenstvo).

</aside>

### Числовой разделитель

В спецификации EcmaScript 2021 года (_ES12_) появилась возможность добавлять в числа разделители. Например:

```js
const number = 1_000_000_000

console.log(number)
// 1000000000
```

Разделители делают большие числа более читаемыми, внешне выделяя разряды чисел.

```js
const integer = 1_234_567_890
const float = 0.123_456_789
```

Разделители доступны для чисел других счислений и [`BigInt`](/js/bigint/):

```js
const binary = 0b0101_1111_0001
const hex = 0x12_AB_34_CD
const bigInt = 1_234_567_890n
```

### Дополнительные методы

Сам по себе примитивный тип «число» не имеет методов. Когда происходит вызов метода у числа, оно автоматически оборачивается в специальную обёртку, которая и содержит методы:

```js
const num = 99.99

console.log(num.toFixed(1))
// 100.0
```

Часто используемые методы обёртки, такие как `toFixed()`, [`toString()`](/js/number-tostring/) и `toLocaleString()`, описаны в [отдельной статье](/js/number-wrapper/).

