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