Skip to main content

Числа

В современном JavaScript существует два типа чисел:

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

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

let billion = 1000000000;
let billion = 1_000_000_000
let billion = 1e9;
let mcs = 0.000001;
let ms = 1e-6; // шесть нулей слева от 1
let a = 0b11111111; // двоичная (бинарная) форма записи числа 255
let b = 0o377; // восьмеричная форма записи числа 255

toString(base)​

base может варьироваться от 2 до 36 (по умолчанию 10).

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 для хранения положения десятичной точки и один бит отведён на хранение знака.

alert( 1e500 ); // Infinity

Наиболее часто встречающаяся ошибка при работе с числами в JavaScript – это потеря точности.

alert( 0.1 + 0.2 ); // 0.30000000000000004

И когда мы суммируем 2 числа, их «неточности» тоже суммируются. Наиболее надёжный способ — это округлить результат используя метод toFixed(n):

alert( +(0.1 + 0.2).toFixed(2) ); // 0.3

Проверка: isFinite и isNaN​

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

isNaN(value) преобразует значение в число и проверяет является ли оно NaN:

alert( isNaN(NaN) ); // true
alert( isNaN("str") ); // true
alert( NaN === NaN ); // false

isFinite(value) преобразует аргумент в число и возвращает true, если оно является обычным числом, т.е. не NaN/Infinity/-Infinity Иногда isFinite используется для проверки, содержится ли в строке число:

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.

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.

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() имеет необязательный второй параметр. Он определяет систему счисления,

alert( parseInt('100px') ); // 100
alert( parseFloat('12.5em') ); // 12.5
alert( +"100px" ); // NaN
alert( parseInt('a123') ); // NaN

Другие математические функции​

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

🚀 Источник: https://learn.javascript.ru/number