Числа (объект Number)

В 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).