В JavaScript есть только один тип числа. Числа могут быть написаны с десятичными или без десятичных знаков.
var x = 3.14; // Число с десятичными знаками
var y = 3; // Число без десятичных знаков
Сверхбольшие или сверхмалые числа можно записывать в экспоненциальной нотации:
var x = 123e5; // 12300000
var y = 123e-5; // 0.00123
JavaScript числа всегда являются 64-битными числами с плавающей запятой
В отличие от многих других языков программирования, JavaScript не определяет различные типы чисел, такие как целые, короткие, длинные, числа с плавающей запятой и т.д.
Числа JavaScript всегда хранятся как числа с плавающей запятой двойной точности в соответствии с международным стандартом IEEE 754.
В этом формате числа хранятся в 64-битном формате, где число (дробь) хранится в битах от 0 до 51, показатель степени - в битах с 52 по 62, а знак - в битах 63:
| Значение (также известное как дробь / мантисса) | Экспонента | Подписать |
|---|---|---|
| 52 bits (0 - 51) | 11 bits (52 - 62) | 1 bit (63) |
JavaScript Точность
Целые числа (числа без точки или показателя степени) имеют точность до 15 цифр.
var x = 999999999999999; // x будет 999999999999999
var y = 9999999999999999; // y будет 10000000000000000
Попробуйте сами »
Максимальное количество десятичных знаков — 17.
JavaScript Плавающая точность
Арифметика с плавающей запятой не всегда точна на 100%:
var x = 0.2 + 0.1; // x будет 0.30000000000000004
Чтобы решить указанную выше задачу, помогает умножать и делить:
var x = (0.2 * 10 + 0.1 * 10) / 10; // x будет 0.3
Попробуйте сами »
JavaScript Добавление чисел и строк
ВНИМАНИЕ !!
В JavaScript оператор + используется как для сложения, так и для объединения.
Номера добавлены. Строки объединяются.
Если сложить два числа, результатом будет число:
var x = 10;
var y = 20;
var z = x + y; // z будет 30 (число)
Попробуйте сами »
Если вы добавите две строки, то результатом будет конкатенация строк:
var x = "10";
var y = "20";
var z = x + y; // z будет 1020 (строка)
Попробуйте сами »
Если вы добавите число и строку, то результатом будет конкатенация строк:
var x = 10;
var y = "20";
var z = x + y; // z будет 1020 (строка)
Попробуйте сами »
Если вы добавите строку и число, то результатом будет конкатенация строк:
var x = "10";
var y = 20;
var z = x + y; // z будет 1020 (строка)
Попробуйте сами »
Распространенной ошибкой является ожидание, что этот результат будет равен 30:
var x = 10;
var y = 20;
var z = "Результат: " + x + y;
Попробуйте сами »
Распространенной ошибкой является ожидание, что этот результат будет равен 102030:
var x = 10;
var y = 20;
var z = "30";
var result = x + y + z;
Попробуйте сами »
Интерпретатор JavaScript работает слева направо.
Сначала добавляется 10 + 20, поскольку x и y – оба числа.
Тогда 30 + "30" объединяется, поскольку z — строка.
JavaScript Числовые строки
Строки 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 использует оператор + для объединения строк.
JavaScript NaN - не число
NaN зарезервированное слово JavaScript, указывающее, что число не является допустимым числом.
Попытка выполнить арифметику с нечисловой строкой приведет к NaN (Не число):
var x = 100 / "Яблоко";
// x будет NaN (Не число)
Однако, если строка содержит числовое значение, результатом будет число:
var x = 100 / "10";
// x будет 10
Попробуйте сами »
Вы можете использовать глобальную функцию JavaScript, isNaN(), чтобы узнать, является ли значение числом:
var x = 100 / "Яблоко";
isNaN(x); //
возвращает true, потому, что x - Hе число
Попробуйте сами »
Остерегайтесь NaN. Если вы используете NaN математическую операцию, результат также будет NaN:
var x = NaN;
var y = 5;
var z = x + y;
// z будет NaN
Попробуйте сами »
Или результатом может быть конкатенация, например NaN5:
var x = NaN;
var y = "5";
var z = x + y; // z будет NaN5
Попробуйте сами »
NaN это число: typeof NaN возвращает number:
typeof NaN; // возвращается "число"
Попробуйте сами »
JavaScript Infinity
Infinity (или -Infinity) - это значение, которое JavaScript вернет, если вы вычислите число за пределами максимально возможного числа.
var
myNumber = 2;
while (myNumber != Infinity) { // Исполнять до бесконечности
myNumber = myNumber * myNumber;
}
Попробуйте сами »Деление на 0 (ноль) также дает Infinity:
var x = 2 / 0;
// x будет Infinity
var y = -2 / 0; // y будет - Infinity
Попробуйте сами »
Infinity - это число:
typeof Infinity возвращается number.
typeof Infinity; // возвращается "число"
Попробуйте сами »
JavaScript Шестнадцатеричный
JavaScript интерпретирует числовые константы как шестнадцатеричные, если им предшествует 0x.
var x = 0xFF; // x будет 255
Попробуйте сами »
Никогда не пишите числа с нуля в начале (например, 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 Числа могут быть объектами
Обычно числа в 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, потому что объекты не могут быть сравнены
Попробуйте сами »
Сравнение двух объектов JavaScript всегда возвращает false.
Полная ссылка на числа JavaScript
Для получения полной информации о числах посетите наш: Полный справочник чисел JavaScript.
Справочник содержит описания и примеры всех свойств и методов Number.