JavaScript Числа
В JavaScript есть только один тип числа. Числа можно писать с десятичными знаками или без них.
Пример
let x = 3.14; // Число с десятичными знаками
let y = 3; // Число без десятичных знаков
Сверхбольшие или сверхмалые числа могут быть записаны в экспоненциальной нотации:
Числа JavaScript всегда являются 64-битными числами с плавающей запятой
В отличие от многих других языков программирования, JavaScript не определяет различные типы чисел, такие как целые, короткие, длинные, числа с плавающей запятой и т.д.
В соответствии с международным стандартом IEEE 754 числа JavaScript всегда хранятся как числа с плавающей запятой двойной точности.
В этом формате числа хранятся в 64-битном формате, где число (дробь) хранится в битах от 0 до 51, показатель степени - в битах с 52 по 62, а знак - в битах 63:
| Значение (также известное как дробь/Мантисса) | Экспонента | Знак |
|---|---|---|
| 52 бит (0 - 51) | 11 бит (52 - 62) | 1 бит (63) |
Точность
Целые числа (числа без точки или показателя степени) имеют точность до 15 цифр.
Пример
let x = 999999999999999; // x будет 999999999999999
let y = 9999999999999999; // y будет 10000000000000000
Попробуйте сами »
Максимальное количество десятичных знаков - 17, но арифметика с плавающей запятой не всегда точна на 100%:
Чтобы решить указанную выше проблему, помогает умножать и делить:
Добавление чисел и строк
ВНИМАНИЕ!!
JavaScript использует оператор + как для сложения, так и для конкатенации.
Числа складываются. Строки объединяются.
Если сложить два числа, получится число:
Если вы сложите две строки, результатом будет конкатенация (объединение) строк.
Если вы сложите число и строку, результатом будет конкатенация строк:
Если вы сложите строку и число, результатом будет конкатенация строк:
Распространённая ошибка - ожидать, что этот результат будет 30:
Распространённой ошибкой является ожидание того, что результат будет 102030:
JavaScript интерпретатор работает слева направо.
Первые 10 + 20 складываются, потому что x и y - оба числа.
Затем 30 + "30" - объединяются, потому что z является строкой (т.к. взято в кавычки).
Числовые строки
JavaScript строки могут иметь числовое содержание:
let x = 100; // x является числом
let y = "100"; // y является строкой
JavaScript попытается преобразовать строки в числа во всех числовых операциях:
Это будет работать:
let x = "100";
let y = "10";
let z = x / y; // z будет 10
Это тоже сработает:
let x = "100";
let y = "10";
let z = x * y; // z будет 1000
И это будет работать:
let x = "100";
let y = "10";
let z = x - y; // z будет 90
Но это не сработает:
let x = "100";
let y = "10";
let z = x + y; // z не будет 110 (будет 10010)
В последнем примере JavaScript использует оператор + для объединения (конкатенации) строк.
NaN - Not a Number (Не число)
NaN - это зарезервированное слово в JavaScript, указывающее, что число не является допустимым числом.
Попытка выполнить арифметику с нечисловой строкой приведет к результату NaN (Not a Number / Не число):
Однако, если строка содержит числовое значение, результатом будет число:
Вы можете использовать глобальную JavaScript функцию isNaN() чтобы узнать, является ли значение числом:
Пример
let x = 100 / "Apple";
isNaN(x); // возвращает true, потому что x является Not a Number
Попробуйте сами »
Следите за NaN. Если вы используете NaN в математической операции, результат также будет NaN:
Или результатом может быть конкатенация (объединение):
NaN является числом: typeof NaN возвращает number:
Infinity / Бесконечность
Infinity (или -Infinity) это значение, которое JavaScript вернёт, если вы вычислите число за пределами максимально возможного числа.
Пример
let myNumber = 2;
while (myNumber != Infinity) { // Выполнить до бесконечности
myNumber = myNumber * myNumber;
}
Попробуйте сами »Деление на 0 (ноль) также даёт Infinity (бесконечность):
Infinity является числом: typeof Infinity возвращает number.
Hexadecimal / Шестнадцатеричные
JavaScript интерпретирует числовые константы как шестнадцатеричные, если им предшествует 0x.
Никогда не пишите числа с нулем в начале (например, 07).
Некоторые версии JavaScript интерпретируют числа как восьмеричные, если они записаны с нулем в начале.
По умолчанию в JavaScript числа отображаются в виде десятичных знаков с основанием 10.
Но вы можете использовать метод toString() для вывода чисел от основания 2 до основания 36.
В шестнадцатеричном формате используется основание 16. В десятичной системе используется основание 10. Восьмеричное число - это основание 8. Двоичный формат - это основание 2.
Пример
let myNumber = 32;
myNumber.toString(10); // вернёт 32
myNumber.toString(32); // вернёт 10
myNumber.toString(16); // вернёт 20
myNumber.toString(8); // вернёт 40
myNumber.toString(2); // вернёт 100000
Попробуйте сами »
Числа могут быть объектами
Обычно числа JavaScript - это примитивные значения, созданные из литералов:
let x = 123;
Но числа также можно определить как объекты с ключевым словом new:
let y = new Number(123);
Пример
let x = 123;
let y = new Number(123);
// typeof x вернёт число
// typeof y вернёт объект
Попробуйте сами »
Не создавайте Number (числовые) объекты. Это снижает скорость выполнения.
Ключевое слово new усложняет код. Это может привести к неожиданным результатам:
При использовании оператора == равные числа равны:
Пример
let x = 500;
let y = new Number(500);
// (x == y) является true, потому что x и y имеют равные значения
Попробуйте сами »
При использовании оператора === равные числа не равны, поскольку оператор === ожидает равенства как по типу, так и по значению.
Пример
let x = 500;
let y = new Number(500);
// (x === y) является false, потому что x и y имеют разные типы
Попробуйте сами »
Или даже хуже. Невозможно сравнивать объекты:
Пример
let x = new Number(500);
let y = new Number(500);
// (x == y) является false, потому что объекты нельзя сравнивать
Попробуйте сами »
Обратите внимание на разницу между (x==y) и (x===y).
Сравнение двух объектов JavaScript всегда будет возвращать false.
