2. Тип данных Number. Его особенности, свойства, методы.

Все числа в JavaScript, как целые так и дробные, имеют тип Number и хранятся в 64-битном формате.

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

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

alert( 0xFF ); // 255 в шестнадцатиричной системе

Экспоненциальное представление, которое выглядит как <число>e<количество нулей>:

alert( 3e5 ); // 300000

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

alert( 3e-5 ); // 0.00003

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

alert( 1 / 0 ); // Infinity

Infinity – особенное численное значение, которое ведет себя в точности как математическая бесконечность. Infinity больше любого числа. Добавление к бесконечности не меняет её:

alert( Infinity + 5 == Infinity ); // true

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

alert( -1 / 0 ); // -Infinity

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

alert( 1e500 ); // Infinity

NaN

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

alert( 0 / 0 ); // NaN

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

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

NaN === NaN // false

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

isNaN(NaN); // true

isNaN("12"); // false, строка преобразовалась к обычному числу 12

isFinite(n)

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

isFinite(1); // true

isFinite(Infinity); // false

isFinite(NaN); // false

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

Большинство арифметических операций и математических функций преобразуют значение в число автоматически. Для того чтобы сделать это явно, обычно перед значением ставят унарный плюс '+':

alert( +"12.34" ); // 12.34

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

alert( +"12test" ); // NaN

Number — конструктор числа.

Number(12); // 12

Number('12.34'); // 12.34

Number('12text'); // NaN

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

В мире HTML/CSS многие значения не являются в точности числами. Например метрики CSS: 10pt или -12px. Для удобного чтения таких значений существует функция parseInt:

parseInt('12px'); // 12

Функция parseInt и ее аналог parseFloat преобразуют строку символ за символом, пока это возможно. При возникновении ошибки возвращается число, которое получилось. Функция parseInt читает из строки целое число, а parseFloat – дробное. Конечно, существуют ситуации, когда parseInt/parseFloat возвращают NaN. Это происходит при ошибке на первом же символе:

parseInt('a123'); // NaN

Функция parseInt также позволяет указать систему счисления, то есть считывать числа, заданные в шестнадцатиричной и других системах счисления:

parseInt('FF', 16); // 255

toPrecision(precision)

— приведение к десятичной форме (precision — число значащих цифр, 1..21)

(123.456789).toPrecision(2); // '1.2e+2'

(123.456789).toPrecision(4); // '123.5

(123.456789).toPrecision(); // '123.456789'

toExponential(fractionDigits)

— приведение к экспоненциальной форме (fractionDigits — количество знаков после запятой, 0..20)

(123.456789).toExponential(0); // 1e+2

(123.456789).toExponential(2); // 1.23e+2

(123.456789).toExponential(5); // 1.23457e+2

toString(radix)

— преобразует число в строку (radix — основание системы счисления, 2..36 (по-умолчанию — 10))

(123.456789).toString(8); // '173.3517003756026054'

(123.456789).toString(16); // '7b.74f01fb82c2c'

Округление

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

Math.floor - округляет вниз

Math.ceil - округляет вверх

Math.round - округляет до ближайшего целого

Math.floor(3.1); // 3

Math.ceil(3.1); // 4

Math.round(3.1); // 3

toFixed(precision)

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

(12.34).toFixed(1); // "12.3"

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

(12.34).toFixed(5) ); // "12.34000"

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

(0.1 + 0.2) == 0.3 // false

(0.1 + 0.2); // 0.30000000000000004

(0.1 + 0.2 > 0.3); // true

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

Число 0.1 (одна десятая) записывается просто в десятичном формате. Но в двоичной системе счисления это бесконечная дробь, так как единица на десять в двоичной системе так просто не делится. Двоичное значение бесконечных дробей хранится только до определенного знака, поэтому возникает неточность. Её даже можно увидеть:

(0.1).toFixed(20); // 0.10000000000000000555

Когда мы складываем 0.1 и 0.2, то две неточности складываются, получаем незначительную, но всё же ошибку в вычислениях. Конечно, это не означает, что точные вычисления для таких чисел невозможны. Например, есть два способа сложить 0.1 и 0.2:

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

1. * 10 + 0.2 * 10) / 10; // 0.3

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

Из 64 бит, отведённых на число, сами цифры числа занимают до 52 бит, остальные 11 бит хранят позицию десятичной точки и один бит – знак. Так что если 52 бит не хватает на цифры, то при записи пропадут младшие разряды.

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

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

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

Math.acos(x) - возвращает арккосинус x (в радианах)

Math.asin(x) - возвращает арксинус x (в радианах)

Math.atan(x) - возвращает арктангенс x (в радианах)

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) - возводит число в степень

Math.abs(x) - возвращает абсолютное значение числа

Math.max(a, b, c...) - возвращает наибольший из списка аргументов

Math.min(a, b, c...) - возвращает наименьший из списка аргументов