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