JavaScript поддерживает как целые числа, так и числа с плавающей точкой, которые могут быть представлены в десятичной, шестнадцатеричной или восьмеричной записи. В отличие от других языков, JavaScript не обрабатывает целые числа и числа с плавающей точкой по-разному. Все числа в JavaScript представлены как числа с плавающей точкой. Вот пример, демонстрирующий числа в разных форматах:
var x = 2; // целое число
var y = 3.14; // число с плавающей точкой
var z = 0xff; // шестнадцатеричное числоОчень большие числа могут быть представлены в экспоненциальной записи, например, 6.02e+23 (аналогично 6.02×1023).
var x = 1.57e4; // тоже самое 15700
var y = 4.25e+6; // тоже самое 4.25e6 или 4250000
var z = 4.25e-6; // тоже самое 0.00000425Самое большое безопасное целое число в JavaScript — 9007199254740991 (253-1), тогда как самое маленькое безопасное целое число -9007199254740991 (-(253-1)).
Числа также могут быть представлены в шестнадцатеричной записи. Шестнадцатеричные числа с префиксом 0x. Они обычно используются для представления цветов. Вот пример:
var x = 0xff; // тоже самое 255
var y = 0xb4; // тоже самое 180
var z = 0x00; // тоже самое 0Целые числа могут быть представлены в десятичной, шестнадцатеричной и восьмеричной нотациях. Числа с плавающей точкой могут быть представлены в десятичной или экспоненциальной записи.
Работа с числами и строками
Как вы знаете из предыдущих глав, оператор + используется как для сложения, так и для объединения. Таким образом, выполнение математических операций над числами и строками может дать интересные результаты. Следующий пример покажет вам, что происходит, когда вы добавляете числа к строкам:
var x = 10;
var y = 20;
var z = "30";
// Добавление числа к числу, результатом будет сумма чисел
console.log(x + y); // 30
// Если добавить строку к строке, результатом будет конкатенация строк
console.log(z + z); // '3030'
// Если добавить число к строке, результатом будет конкатенация строк
console.log(x + z); // '1030'
// Если добавить строку к числу, результатом будет конкатенация строк
console.log(z + x); // '3010'
// Если складывать строки и числа, результатом будет конкатенация строк
console.log("The result is: " + x + y); // 'The result is: 1020'
// Добавление чисел и строк, расчет выполняется слева направо
console.log(x + y + z); // 'The result is: 3030'Если вы внимательно посмотрите на приведенный выше пример, вы обнаружите, что результатом последней операции является не просто конкатенация строк, поскольку операторы с одинаковым приоритетом вычисляются слева направо. Вот почему, поскольку переменные x и y являются числами, они складываюся первыми, тогда результат объединяется с переменной z, которая является строкой равен 30 + "30" = "3030".
Но если вы выполните другие математические операции, такие как умножение, деление или вычитание, результат будет другим. JavaScript автоматически преобразует числовые строки (то есть строки, содержащие числовые значения) в числа во всех числовых операциях, как показано в следующем примере:
var x = 10;
var y = 20;
var z = "30";
// Вычитание числа из числа
console.log(y - x); // 10
// Вычитание числа из числовой строки
console.log(z - x); // 20
// Умножение числа на числовую строку
console.log(x * z); // 300
// Разделение числа на числовую строку
console.log(z / x); // 3Более того, если вы попытаетесь умножить или разделить числа со строками, которые не являются числовыми, он возвращает NaN (не число). Кроме того, если вы используете NaN в математической операции, результатом также будет NaN.
var x = 10;
var y = "foo";
var z = NaN;
// Вычитание числа из не числовой строки
console.log(y - x); // NaN
// Умножение числа на не числовую строку
console.log(x * y); // NaN
// Разделение числа на не числовую строку
console.log(x / y); // NaN
// Добавление NaN к числу
console.log(x + z); // NaN
// Добавление NaN к строке
console.log(y + z); // fooNaNПредставление о бесконечности
Бесконечность представляет число, слишком большое в JavaScript для обработки. В JavaScript есть специальные ключевые слова Infinity и -Infinity для представления положительной и отрицательной бесконечности соответственно. Например, деление на 0 возвращает Infinity, как показано ниже:
var x = 5 / 0;
console.log(x); // Infinity
var y = -5 / 0;
console.log(y); // -InfinityБесконечность — это специальное значение, которое представляет математическую бесконечность ∞, которая больше любого числа. Оператор typeof возвращает число для значения Infinity.
Как избежать проблем с плавающей точкой
Иногда операции с числами с плавающей точкой дают неожиданные результаты, как показано здесь:
var x = 0.1 + 0.2;
console.log(x) // 0.30000000000000004Как видите, результат равен 0.30000000000000004, а не 0.3. Эта разница называется ошибкой представления или ошибкой округления. Это происходит потому, что JavaScript и многие другие языки используют двоичную форму для внутреннего представления десятичных чисел. К сожалению, большинство десятичных дробей не могут быть представлены точно в двоичной форме, поэтому возникают такие ситуации.
Чтобы избежать этой проблемы, вы можете использовать такое решение:
var x = (0.1 * 10 + 0.2 * 10) / 10;
console.log(x) // 0.3JavaScript округляет числа с плавающей запятой до 17 цифр, что является достаточной точностью в большинстве случаев. Кроме того, в JavaScript целые числа (числа без дробных частей или экспоненциальная запись) имеют точность до 15 цифр, как показано в следующем примере:
var x = 999999999999999;
console.log(x); // 999999999999999
var y = 9999999999999999;
console.log(y); // 10000000000000000Выполнение операций над числами
JavaScript предоставляет несколько свойств и методов для выполнения операций над числовыми значениями. Как вы уже знаете из предыдущих глав, в JavaScript примитивные типы данных могут действовать как объекты, когда вы ссылаетесь на них с помощью нотации доступа к свойству (то есть точечной нотации).
В следующих разделах мы рассмотрим методы, которые используются чаще всего.
Разбор целых чисел из строк
Метод parseInt() можно использовать для анализа целого числа из строки. Этот метод особенно удобен в ситуациях, когда вы имеете дело с такими значениями, как единицы CSS, например 50px, 12pt и т. д., И вы хотите извлечь из него числовое значение.
Если метод parseInt() встречает символ, который не является числовым в указанной базе, он прекращает синтаксический анализ и возвращает целочисленное значение, проанализированное до этого символа. Если первый символ не может быть преобразован в число, метод вернет NaN (не число).
Начальные и конечные пробелы разрешены. Вот пример:
console.log(parseInt("3.14")); // 3
console.log(parseInt("50px")); // 50
console.log(parseInt("12pt")); // 12
console.log(parseInt("0xFF", 16)); // 255
console.log(parseInt("20 years")); // 20
console.log(parseInt("Year 2048")); // NaN
console.log(parseInt("10 12 2018")); // 10Метод parseInt() усекает числа до целочисленных значений, но его не следует использовать вместо метода Math.floor().
Точно так же вы можете использовать метод parseFloat() для анализа числа с плавающей запятой из строки. Метод parseFloat() работает так же, как и метод parseInt(), за исключением того, что он извлекает как целые числа, так и числа с десятичными знаками.
console.log(parseFloat("3.14")); // 3.14
console.log(parseFloat("50px")); // 50
console.log(parseFloat("1.6em")); // 1.6
console.log(parseFloat("124.5 lbs")); // 124.5
console.log(parseFloat("weight 124.5 lbs")); // NaN
console.log(parseFloat("6.5 acres")); // 6.5Преобразование чисел в строки
Метод toString() можно использовать для преобразования числа в его строковый эквивалент. Этот метод дополнительно принимает целочисленный параметр в диапазоне от 2 до 36, указывающий основание, используемое для представления числовых значений. Вот пример:
var x = 10;
var y = x.toString();
console.log(y); // '10'
console.log(typeof y); // string
console.log(typeof x); // number
console.log((12).toString()); // '12'
console.log((15.6).toString()); // '15.6'
console.log((6).toString(2)); // '110'
console.log((255).toString(16)); // 'ff'Форматирование чисел в экспоненциальной записи
Вы можете использовать метод toExponential() для форматирования или представления числа в экспоненциальной записи. Этот метод дополнительно принимает целочисленный параметр, указывающий количество цифр после десятичной точки. Кроме того, возвращаемое значение является строкой, а не числом. Вот пример:
var x = 67.1234;
console.log(x.toExponential()); // 6.71234e+1
console.log(x.toExponential(6)); // 6.712340e+1
console.log(x.toExponential(4)); // 6.7123e+1
console.log(x.toExponential(2)); // 6.71e+1Экспоненциальная запись полезна для представления чисел, которые либо очень большие, либо очень маленькие по величине. Например, 62500000000 можно записать как 625e + 8 или 6.25e + 10.
Форматирование чисел в фиксированные десятичные дроби
Вы можете использовать метод toFixed(), когда хотите отформатировать число с фиксированным числом цифр справа от десятичной точки. Значение, возвращаемое этим методом, является строкой и имеет точно указанное количество цифр после десятичной точки. Если параметр digits не указан или опущен, он обрабатывается как 0. Вот пример:
var x = 72.635;
console.log(x.toFixed()); // '73' (note rounding, no fractional part)
console.log(x.toFixed(2)); // '72.64' (note rounding)
console.log(x.toFixed(1)); // '72.6'
var y = 6.25e+5;
console.log(y.toFixed(2)); // '625000.00'
var z = 1.58e-4;
console.log(z.toFixed(2)); // '0.00' (since 1.58e-4 is equal to 0.000158)Точное форматирование чисел
Если вы хотите получить подходящую форму числа, вы можете вместо этого использовать метод toPrecision(). Этот метод возвращает строку, представляющую число с заданной точностью.
Если точность достаточно велика, чтобы включить все цифры целочисленной части числа, то число форматируется с использованием записи с фиксированной запятой. В противном случае число форматируется с использованием экспоненциальной записи. Параметр точности является необязательным. Вот пример:
var x = 6.235;
console.log(x.toPrecision()); // '6.235'
console.log(x.toPrecision(3)); // '6.24' (note rounding)
console.log(x.toPrecision(2)); // '6.2'
console.log(x.toPrecision(1)); // '6'
var y = 47.63;
console.log(y.toPrecision(2)); // '48' (note rounding, no fractional part)
var z = 1234.5;
console.log(z.toPrecision(2)); // '1.2e+3'Поиск наибольших и наименьших возможных чисел
С объектом Number также связано несколько свойств. Свойства Number.MAX_VALUE и Number.MIN_VALUE объекта Number представляют самые большие и самые маленькие (самые близкие к нулю, не самые отрицательные) возможные положительные числа, которые может обрабатывать JavaScript. Они являются константами, и их фактические значения составляют 1.7976931348623157e+308 и 5e-324 соответственно.
Число, которое выходит за пределы диапазона возможных чисел, представлено константой Number.POSITIVE_INFINITY или Number.NEGATIVE_INFINITY. Вот пример:
var a = Number.MAX_VALUE;
console.log(a); // 1.7976931348623157e+308
var b = Number.MIN_VALUE;
console.log(b); // 5e-324
var x = Number.MAX_VALUE * 2;
console.log(x); // Infinity
var y = -1 * Number.MAX_VALUE * 2;
console.log(y); // -InfinityТакже ознакомьтесь с Руководством по математическим операциям JavaScript, чтобы узнать об округлении чисел, генерации случайного числа, поиске максимального или минимального значения из набора чисел и т. д.
