Работа с числами в js

Все числа в JavaScript, как целые так и дробные, имеют тип Number и хранятся в 64-битном форматеIEEE-754, также известном как «double precision».

Здесь мы рассмотрим различные тонкости, связанные с работой с числами в JavaScript.

Способы записи

В JavaScript можно записывать числа не только в десятичной, но и в шестнадцатеричной (начинается с0x), а также восьмеричной (начинается с 0) системах счисления:

Также доступна запись в «научном формате» (еще говорят «запись с плавающей точкой»), который выглядит как <число>e<кол-во нулей>.

Например, 1e3 — это 1 с 3 нулями, то есть 1000.

Если количество нулей отрицательно, то число сдвигается вправо за десятичную точку, так что получается десятичная дробь:

Деление на ноль, Infinity

Представьте, что вы собираетесь создать новый язык… Люди будут называть его «JavaScript» (или LiveScript… неважно).

Что должно происходить при попытке деления на ноль?

Как правило, ошибка в программе… Во всяком случае, в большинстве языков программирования это именно так.

Но создатель JavaScript решил более «математическим» путем. Ведь чем меньше делитель, тем больше результат. При делении на очень-очень маленькое число должно получиться очень большое. В математическом анализе это описывается через пределы, но если упрощенно, то в качестве результата деления на 0 мы получаем «бесконечность», которая обозначается символом ∞ или, в JavaScript: "Infinity".

Infinity — особенное численное значение, которое ведет себя в точности как математическая бесконечность ∞.

• Infinity больше любого числа.
• Добавление к бесконечности не меняет ее.

Бесконечность можно присвоить и в явном виде: var x = Infinity.

Бывает и минус бесконечность -Infinity:

Бесконечность можно получить также, если сделать ну очень большое число, для которого количество разрядов в двоичном представлении не помещается в соответствующую часть стандартного 64-битного формата, например:

NaN

Если математическая операция не может быть совершена, то возвращается специальное значение NaN (Not-A-Number).

Например, деление 0/0 в математическом смысле неопределено, поэтому возвращает NaN:

Значение NaN используется для обозначения математической ошибки и обладает следующими свойствами:

• Значение NaN — единственное, в своем роде, которое не равно ничему, включая себя.

  Следующий код ничего не выведет:

     

  1	if (NaN == NaN) alert("=="); // Ни один вызов

  2	if (NaN === NaN) alert("==="); // не сработает

   

• Значение NaN можно проверить специальной функцией isNaN(n), которая возвращает true если аргумент — NaN и false для любого другого значения.
     

  1	var n = 0/0;

  2

  3	alert( isNaN(n) ); // true

   

  Еще один забавный способ проверки значения на NaN — это проверить его на равенство самому себе, вот так:

     

  1	var n = 0/0;

  2

  3	if (n !== n) alert('n = NaN!');

  Это работает, но для наглядности лучше использовать isNaN.

   

   

• Значение NaN «прилипчиво». Любая операция с NaN возвращает NaN.
     

  1	alert( NaN + 1 ); // NaN

Если аргумент isNaN — не число, то он автоматически преобразуется к числу.

isFinite(n)

Итак, в JavaScript есть обычные числа и три специальных числовых значения: NaN, Infinity и-Infinity.

Функция isFinite(n) возвращает true только тогда, когда n — обычное число, а не одно из этих значений:

Если аргумент isFinite — не число, то он автоматически преобразуется к числу.

Преобразование к числу

Строгое преобразование можно осуществить унарным плюсом '+'

Строгое — означает, что если строка не является в точности числом, то результат будет NaN:

Единственное исключение — пробельные символы в начале и в конце строки, которые игнорируются:

Аналогичным образом происходит преобразование и в других математических операторах и функциях:

isNaN — проверка на число для строк

Функция isNaN является математической, она преобразует аргумент в число, а затем проверяет, NaNэто или нет.

Поэтому можно использовать ее для проверки:

Единственный тонкий момент — в том, что пустая строка и строка из пробельных символов преобразуются к 0:

И, конечно же, проверка isNaN посчитает числами значения false, true, null, т.к. они хотя и не числа, но преобразуются к ним:

Мягкое преобразование: parseInt и parseFloat

В мире HTML/CSS многие значения не являются в точности числами. Например, метрики CSS: 10ptили -12px.

Оператор '+' для таких значений возвратит NaN:

Для удобного чтения таких значений существует функция parseInt:

parseInt и ее аналог parseFloat преобразуют строку символ за символом, пока это возможно.

При возникновении ошибки возвращается число, которое получилось. parseInt читает из строки целое число, а parseFloat — дробное.

Конечно, существуют ситуации, когда parseInt/parseFloat возвращают NaN. Об этом говорит сайт https://intellect.icu . Это происходит при ошибке на первом же символе:

Проверка на число для всех типов

Если вам нужна действительно точная проверка на число, которая не считает числом строку из пробелов, логические и специальные значения — используйте следующую функцию isNumeric:

Разберемся, как она работает. Начнем справа.

• Функция isFinite(n) преобразует аргумент к числу и возвращает true, если это неInfinity/-Infinity/NaN.

  Таким образом, правая часть отсеет заведомо не-числа, но оставит такие значения какtrue/false/null и пустую строку '', т.к. они корректно преобразуются в числа.

• Для их проверки нужна левая часть. Вызов parseFloat(true/false/null/'') вернет NaN для этих значений.

  Так устроена функция parseFloat: она преобразует аргумент к строке, т.е. true/false/nullстановятся "true"/"false"/"null", а затем считывает из нее число, при этом пустая строка дает NaN.

В результате отсеивается все, кроме строк-чисел и обычных чисел.

toString(система счисления)

Как показано выше, числа можно записывать не только в 10-чной, но и в 16-ричной системе. Но бывает и противоположная задача: получить 16-ричное представление числа. Для этого используется методtoString(основание системы), например:

Основание может быть любым от 2 до 36.

• Основание 2 бывает полезно для отладки битовых операций, которые мы пройдем чуть позже:
     

  1	var n = 4;

  2	alert( n.toString(2) ); // 100

• Основание 36 (по количеству букв в английском алфавите — 26, вместе с цифрами, которых 10) используется для того, чтобы «кодировать» число в виде буквенно-цифровой строки. В этой системе счисления сначала используются цифры, а затем буквы от a до z:
     

  1	var n = 1234567890;

  2	alert( n.toString(36) ); // kf12oi

  При помощи такого кодирования можно сделать длинный цифровой идентификатор короче, чтобы затем использовать его в URL.

Округление

Одна из самых частых операций с числом — округление. В JavaScript существуют целых 3 функции для этого.

Math.floor

Округляет вниз

Math.ceil

Округляет вверх

Math.round

Округляет до ближайшего целого

Округление до заданной точности

Обычный трюк — это умножить и поделить на 10 с нужным количеством нулей. Например, округлим3.456 до 2го знака после запятой:

Таким образом можно округлять число и вверх и вниз.

num.toFixed(precision)

Существует специальный метод num.toFixed(precision), который округляет число num до точностиprecision и возвращает результат в виде строки:

Округление идет до ближайшего значения, аналогично Math.round:

Итоговая строка, при необходимости, дополняется нулями до нужной точности:

Если нам нужно именно число, то мы можем получить его, применив '+' к результату n.toFixed(..):

Неточные вычисления

Запустите этот пример:

Запустили? Если нет — все же сделайте это.

Ок, вы запустили его. Результат несколько странный, не так ли? Возможно, ошибка в браузере? Поменяйте браузер, запустите еще раз.

Хорошо, теперь мы можем быть уверены: 0.1 + 0.2 это не 0.3. Но тогда что же это?

Как видите, произошла небольшая вычислительная ошибка.

Дело в том, что в стандарте IEEE 754 на число выделяется ровно 8 байт(=64 бита), не больше и не меньше.

Число 0.1 (=1/10) короткое в десятичном формате, а в двоичной системе счисления это бесконечная дробь (перевод десятичной дроби в двоичную систему). Также бесконечной дробью является0.2 (=2/10).

Двоичное значение бесконечных дробей хранится только до определенного знака, поэтому возникает неточность. Это даже можно увидеть:

Когда мы складываем 0.1 и 0.2, то две неточности складываются, получаем третью.

Конечно, это не означает, что точные вычисления для таких чисел невозможны. Они возможны. И даже необходимы.

Например, есть два способа сложить 0.1 и 0.2:

1. Сделать их целыми, сложить, а потом поделить:
      

   1	alert( (0.1*10 + 0.2*10) / 10 ); // 0.3

   Это работает, т.к. числа 0.1*10 = 1 и 0.2*10 = 2 могут быть точно представлены в двоичной системе.

2. Сложить, а затем округлить до разумного знака после запятой. Округления до 10-го знака обычно бывает достаточно, чтобы отсечь ошибку вычислений:
      

   1	var result = 0.1 + 0.2;

   2	alert( +result.toFixed(10) ); // 0.3

Ради справедливости заметим, что в точности то же самое происходит в любом другом языке, где используется формат IEEE 754, включая Java, C, PHP, Ruby, Perl.

Другие математические методы

JavaScript предоставляет базовые тригонометрические и некоторые другие функции для работы с числами.

Тригонометрия

Встроенные функции для тригонометрических вычислений:

Math.acos(x)

Возвращает арккосинус x (в радианах)

Math.asin(x)

Возвращает арксинус x (в радианах)

Math.atan

Возвращает арктангенс x (в радианах)

Math.atan2(y, x)

Возвращает угол до точки (y, x). Описание функции: Atan2.

Math.sin(x)

Вычисляет синус x (в радианах)

Math.cos(x)

Вычисляет косинус x (в радианах)

Math.tan(x)

Возвращает тангенс x (в радианах)

Функции общего назначения

Разные полезные функции:

Math.sqrt(x)

Возвращает квадратный корень из x.

Math.log(x)

Возвращает натуральный (по основанию e) логарифм x.

Math.pow(x, exp)

Возводит число в степень, возвращает xexp, например Math.pow(2,3) = 8. Работает в том числе с дробными и отрицательными степенями, например: Math.pow(4, -1/2) = 0.5.

Math.abs(x)

Возвращает абсолютное значение числа

Math.exp(x)

Возвращает ex, где e — основание натуральных логарифмов.

Math.max(a, b, c...)

Возвращает наибольший из списка аргументов

Math.min(a, b, c...)

Возвращает наименьший из списка аргументов

Math.random()

Возвращает псевдо-случайное число в интервале [0,1) - то есть между 0(включительно) и 1(не включая). Генератор случайных чисел инициализуется текущим временем.

Итого

• Числа могут быть записаны в шестнадцатиричной, восьмеричной системе, а также «научным» способом.
• В JavaScript существует числовое значение бесконечность Infinity.
• Ошибка вычислений дает NaN.
• Арифметические и математические функции преобразуют строку в точности в число, игнорируя начальные и конечные пробелы.
• Функции parseInt/parseFloat делают числа из строк, которые начинаются с числа.
• Есть четыре способа округления: Math.floor, Math.round, Math.ceil и битовый оператор. Для округления до нужного знака используйте +n.toFixed(p) или трюк с умножением и делением на10p.
• Дробные числа дают ошибку вычислений. При необходимости ее можно отсечь округлением до нужного знака.
• Случайные числа от 0 до 1 генерируются с помощью Math.random(), остальные — преобразованием из них.

Существуют и другие математические функции. Вы можете ознакомиться с ними в справочнике в разделах Number и Math.