Число

Значения Number представляют собой числа с плавающей запятой, например 37 или -9.25.

Конструктор Number содержит константы и методы для работы с числами. Значения других типов можно преобразовать в числа с помощью функции Number().

Описание

Числа чаще всего записывают в виде литералов, например 255 или 3.14159. Более подробная справочная информация содержится в лексической грамматике.

255; // two-hundred and fifty-five
255.0; // same number
255 === 255.0; // true
255 === 0xff; // true (hexadecimal notation)
255 === 0b11111111; // true (binary notation)
255 === 0.255e3; // true (decimal exponential notation)

Числовой литерал, например 37 в коде JavaScript, является числом с плавающей запятой, а не целым числом. В повседневном использовании отдельного типа для целых чисел нет. (В JavaScript также есть тип BigInt, но он не предназначен для повседневной замены Number. 37 — это по-прежнему число, а не BigInt.)

При вызове в виде функции Number(value) преобразует строку или другое значение в тип Number. Если значение нельзя преобразовать, возвращается NaN.

Number("123"); // returns the number 123
Number("123") === 123; // true

Number("unicorn"); // NaN
Number(undefined); // NaN

Представление чисел

Тип JavaScript Number представляет собой значение в формате IEEE 754 с двойной точностью, 64-битный двоичный формат, как double в Java или C#. Это означает, что он может представлять дробные значения, но существуют ограничения на величину и точность хранимого числа. Если кратко, число двойной точности IEEE 754 использует 64 бита для представления трех частей:

• 1 бит для знака (положительного или отрицательного)
• 11 бит для показателя степени (от -1022 до 1023)
• 52 бита для мантиссы (представляющей число от 0 до 1)

Мантисса (также называемая значащей частью) — это часть числа, представляющая фактическое значение (значащие цифры). Показатель степени — это степень числа 2, на которую нужно умножить мантиссу. Если представить это в виде научной нотации:

Мантисса хранится в 52 битах, которые интерпретируются как цифры после 1.… в двоичной дроби. Поэтому точность мантиссы составляет 2^-52 (это значение можно получить с помощью Number.EPSILON), или примерно от 15 до 17 значащих десятичных цифр; арифметические операции, требующие большей точности, подвержены округлению.

Наибольшее значение, которое может хранить число, равно 2¹⁰²³ × (2 - 2^-52) (показатель степени равен 1023, а мантисса — 0.1111… в системе счисления с основанием 2). Это значение можно получить с помощью Number.MAX_VALUE. Более высокие значения заменяются специальной числовой константой Infinity.

Целые числа можно представлять без потери точности только в диапазоне от -2⁵³ + 1 до 2⁵³ - 1 включительно (эти границы можно получить с помощью Number.MIN_SAFE_INTEGER и Number.MAX_SAFE_INTEGER), поскольку мантисса может хранить только 53 бита (включая ведущую 1).

Подробнее об этом говорится в стандарте ECMAScript.

Преобразование к типу Number

Многие встроенные операции, которым требуются числа, сначала преобразуют свои аргументы к числам (именно поэтому объекты Number во многом ведут себя так же, как примитивные значения типа number). Операцию можно кратко описать следующим образом:

• Числа возвращаются без изменений.
• undefined преобразуется в NaN.
• null преобразуется в 0.
• true преобразуется в 1; false преобразуется в 0.
• Строки преобразуются путем разбора так, будто они содержат числовой литерал. Если разбор завершается неудачей, возвращается NaN. Есть несколько небольших отличий от обычного числового литерала:
  • Начальные и конечные пробелы и символы перевода строки игнорируются.
  • Начальная цифра 0 не приводит к тому, что число становится восьмеричным литералом (и не вызывает ошибку в строгом режиме).
  • В начале строки допускаются + и -, обозначающие знак числа. (В коде они «выглядят» как часть литерала, но на самом деле являются отдельными унарными операторами.) Однако знак может встречаться только один раз, и после него не должно быть пробелов.
  • Infinity и -Infinity распознаются как литералы. В коде же это глобальные переменные.
  • Пустые строки и строки, содержащие только пробельные символы, преобразуются в 0.
  • Разделители чисел не допускаются.
• Для предотвращения непреднамеренного неявного преобразования, приводящего к потере точности, при использовании BigInt возникает ошибка TypeError.
• При использовании символов возникает ошибка TypeError.
• Сначала объекты преобразуются в примитивные значения путем вызова методов [Symbol.toPrimitive]() (с подсказкой "number"), valueOf() и toString() именно в таком порядке. Затем полученное примитивное значение преобразуется в число.

В JavaScript есть два способа добиться почти одинакового результата.

• Унарный плюс: +x выполняет описанные выше шаги преобразования к типу Number для преобразования x.
• Функция Number(): Number(x) использует тот же алгоритм для преобразования x, за исключением того, что при использовании BigInt не возникает ошибка TypeError: вместо этого возвращается числовое значение, возможно с потерей точности.

Number.parseFloat() и Number.parseInt() похожи на Number(), но преобразуют только строки и используют немного отличающиеся правила разбора. Например, parseInt() не распознает десятичную точку, а parseFloat() не распознает префикс 0x.

Преобразование в целое число

Некоторым операциям требуются целые числа, в частности операциям с индексами массивов и строк, компонентами даты и времени, а также основаниями систем счисления. После выполнения описанных выше шагов преобразования к типу Number результат усекается до целого числа (дробная часть отбрасывается). Если число равно ±Infinity, оно возвращается без изменений. Если число равно NaN или -0, возвращается 0. Таким образом, результат всегда является целым числом (не -0) или ±Infinity.

Примечательно, что при преобразовании в целые числа и undefined, и null становятся 0, поскольку undefined преобразуется в NaN, которое также становится 0.

Преобразование чисел фиксированной разрядности

В JavaScript есть несколько низкоуровневых функций, работающих с двоичным представлением целых чисел; в частности, это побитовые операторы и объекты TypedArray. Побитовые операторы всегда преобразуют операнды в 32-битные целые числа. В таких случаях после преобразования значения в число оно нормализуется до заданной разрядности: сначала его дробная часть отсекается, а затем берутся младшие биты целого числа в дополнительном коде.

new Int32Array([1.1, 1.9, -1.1, -1.9]); // Int32Array(4) [ 1, 1, -1, -1 ]

new Int8Array([257, -257]); // Int8Array(2) [ 1, -1 ]
// 257 = 0001 0000 0001
//     =      0000 0001 (mod 2^8)
//     = 1
// -257 = 1110 1111 1111
//      =      1111 1111 (mod 2^8)
//      = -1 (as signed integer)

new Uint8Array([257, -257]); // Uint8Array(2) [ 1, 255 ]
// -257 = 1110 1111 1111
//      =      1111 1111 (mod 2^8)
//      = 255 (as unsigned integer)

Конструктор

Number()

Создает объекты Number. При вызове в виде функции возвращает примитивные значения типа Number.

Статические свойства

Number.EPSILON

Наименьший интервал между двумя представимыми числами.

Number.MAX_SAFE_INTEGER

Наибольшее безопасное целое число в JavaScript (2⁵³ - 1).

Number.MAX_VALUE

Наибольшее положительное представимое число.

Number.MIN_SAFE_INTEGER

Наименьшее безопасное целое число в JavaScript (-(2⁵³ - 1)).

Number.MIN_VALUE

Наименьшее положительное представимое число, то есть положительное число, ближайшее к нулю (но не равное ему).

Number.NaN

Специальное значение «Nе число».

Number.NEGATIVE_INFINITY

Специальное значение, представляющее отрицательную бесконечность. Возвращается при переполнении.

Number.POSITIVE_INFINITY

Специальное значение, представляющее бесконечность. Возвращается при переполнении.

Статические методы

Number.isFinite()

Проверяет, является ли переданное значение конечным числом.

Number.isInteger()

Проверяет, является ли переданное значение целым числом.

Number.isNaN()

Проверяет, является ли переданное значение NaN.

Number.isSafeInteger()

Проверяет, является ли переданное значение безопасным целым числом (числом в диапазоне от -(2⁵³ - 1) до 2⁵³ - 1).

Number.parseFloat()

Это тот же метод, что и глобальная функция parseFloat().

Number.parseInt()

Это тот же метод, что и глобальная функция parseInt().

Свойства экземпляров

Эти свойства определены в Number.prototype и доступны всем экземплярам Number.

Number.prototype.constructor

Функция-конструктор, создавшая объект экземпляра. Для экземпляров Number исходным значением является конструктор Number.

Методы экземпляров

Number.prototype.toExponential()

Возвращает строку, представляющую число в экспоненциальной записи.

Number.prototype.toFixed()

Возвращает строку, представляющую число в формате с фиксированной точкой.

Number.prototype.toLocaleString()

Возвращает строку с представлением этого числа, учитывающим языковые настройки. Переопределяет метод Object.prototype.toLocaleString().

Number.prototype.toPrecision()

Возвращает строку, представляющую число с заданной точностью в формате с фиксированной точкой или в экспоненциальной записи.

Number.prototype.toString()

Возвращает строку, представляющую указанный объект в заданной системе счисления (radix, «основание»). Переопределяет метод Object.prototype.toString().

Number.prototype.valueOf()

Возвращает примитивное значение указанного объекта. Переопределяет метод Object.prototype.valueOf().

Примеры

Использование объекта Number для присваивания значений числовым переменным

В следующем примере свойства объекта Number используются для присваивания значений нескольким числовым переменным:

const biggestNum = Number.MAX_VALUE;
const smallestNum = Number.MIN_VALUE;
const infiniteNum = Number.POSITIVE_INFINITY;
const negInfiniteNum = Number.NEGATIVE_INFINITY;
const notANum = Number.NaN;

Диапазон целых чисел для Number

В следующем примере показаны минимальное и максимальное целые числа, которые можно представить в виде объекта Number.

const biggestInt = Number.MAX_SAFE_INTEGER; // (2**53 - 1) => 9007199254740991
const smallestInt = Number.MIN_SAFE_INTEGER; // -(2**53 - 1) => -9007199254740991

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

Возможный способ обойти это ограничение — использовать String.

Для представления более крупных чисел можно использовать тип BigInt.

Использование Number() для преобразования объекта Date

В следующем примере объект Date преобразуется в числовое значение с помощью Number, вызванной в виде функции:

const d = new Date("1995-12-17T03:24:00");
console.log(Number(d));

В журнал будет выведено 819199440000.

Преобразование числовых строк и null в числа

Number("123"); // 123
Number("123") === 123; // true
Number("12.3"); // 12.3
Number("12.00"); // 12
Number("123e-1"); // 12.3
Number(""); // 0
Number(null); // 0
Number("0x11"); // 17
Number("0b11"); // 3
Number("0o11"); // 9
Number("foo"); // NaN
Number("100a"); // NaN
Number("-Infinity"); // -Infinity

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

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

См. также

• Полифил современного поведения Number (с поддержкой двоичных и восьмеричных литералов) в core-js
• NaN
• Арифметические операторы
• Math
• BigInt