3.2.2 Числа в ES6

Представление чисел

Новая нотация для двоичных литералов: префикс 0b или 0B.

console.log(0b11 === 3); // true
console.log(0B11 === 3); // true

Новая нотация для восьмеричных литералов: префикс 0o или 0O.

console.log(0o11 === 9); // true
console.log(0O11 === 9); // true

Константы

Number.EPSILON

Свойство Number.EPSILON представляет разницу между 1 и наименьшим числом с плавающей запятой, которое больше 1.

Его значение приблизительно равно 2.2204460492503130808472633361816E-16, или 2^-52.

Проверить, находится ли число в пределах допустимой погрешности:

0.1 + 0.2 === 0.3; // false
// 在误差范围内即视为相等
equal = (Math.abs(0.1 - 0.3 + 0.2) < Number.EPSILON); // true

Атрибуты свойства

writable：false
enumerable：false
configurable：false

Максимальное / минимальное безопасное целое число

Безопасное целое число

Безопасное целое число — это целое число, которое может быть точно представлено в JavaScript. Диапазон безопасных целых чисел — от минус 2 в 53-й степени до 2 в 53-й степени (не включая обе границы). Целые числа за пределами этого диапазона не могут быть точно представлены.

Максимальное безопасное целое число

Верхняя граница диапазона безопасных целых чисел, т. е. 2 в 53-й степени минус 1.

Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true Number.MAX_SAFE_INTEGER === Number.MAX_SAFE_INTEGER + 1; // false Number.MAX_SAFE_INTEGER - 1 === Number.MAX_SAFE_INTEGER - 2; // false

Минимальное безопасное целое число

Нижняя граница диапазона безопасных целых чисел, т. е. отрицательное значение (2 в 53-й степени минус 1).

Number.MIN_SAFE_INTEGER + 1 === Number.MIN_SAFE_INTEGER + 2; // false Number.MIN_SAFE_INTEGER === Number.MIN_SAFE_INTEGER - 1; // false Number.MIN_SAFE_INTEGER - 1 === Number.MIN_SAFE_INTEGER - 2; // true

Атрибуты свойства

writable：false
enumerable：false
configurable：false

Методы

Новые методы объекта Number

Number.isFinite()

Используется для проверки, является ли число конечным, т. е. не Infinity.

console.log( Number.isFinite(1)); // true console.log( Number.isFinite(0.1)); // true //NaN не является конечным числом. console.log( Number.isFinite(NaN)); // false console.log( Number.isFinite(Infinity)); // false console.log( Number.isFinite(-Infinity)); // false //Number.isFinate не выполняет неявное преобразование типа с помощью Number(); он возвращает false для всех нечисловых значений. console.log( Number.isFinite('foo')); // false console.log( Number.isFinite('15')); // false console.log( Number.isFinite(true)); // false Number.isNaN()Используется для проверки, является ли значениеNaN 。 console.log(Number.isNaN(NaN)); // true console.log(Number.isNaN('true'/0)); // true //В глобальной функции isNaN() все следующие возвращают true, потому что нечисловые значения преобразуются в числа перед проверкой. //Однако Number.isNaN() не выполняет неявное преобразование типа Number(); все значения, которые не являются NaN, возвращают false. Number.isNaN("NaN"); // false Number.isNaN(undefined); // false Number.isNaN({}); // false Number.isNaN("true"); // false

Методы, перенесённые из глобального объекта в объект Number

Постепенное сокращение количества глобальных методов для модуляризации глобальных переменных.

Поведение методов не изменилось.

Number.parseInt()

Используется для преобразования заданной строки в целое число с указанным основанием системы счисления.

//Если основание системы счисления не указано, по умолчанию используется основание 10. Number.parseInt('12.34'); // 12 Number.parseInt(12.34); // 12 //Указание основания системы счисления Number.parseInt('0011',2); // 3 //Это та же функция, что и глобальная функция parseInt(). Number.parseInt === parseInt; // true Number.parseFloat()Используется для разбора строки в число с плавающей запятой.Number.parseFloat('123.45') // 123.45 Number.parseFloat('123.45abc') // 123.45 //Если его нельзя разобрать как число с плавающей запятой, возвращается NaN. Number.parseFloat('abc') // NaN //Это тот же метод, что и глобальный метод parseFloat(). Number.parseFloat === parseFloat // true Number.isInteger()Используется для определения, является ли данный аргумент целым числом.Number.isInteger(value) Number.isInteger(0); // true //Внутри JavaScript использует один и тот же способ хранения для целых и чисел с плавающей точкой, поэтому 1 и 1.0 считаются одним и тем же значением. Number.isInteger(1); // true Number.isInteger(1.0); // true Number.isInteger(1.1); // false Number.isInteger(Math.PI); // false //NaN и положительная/отрицательная Infinity не являются целыми числами. Number.isInteger(NaN); // false Number.isInteger(Infinity); // false Number.isInteger(-Infinity); // false Number.isInteger("10"); // false Number.isInteger(true); // false Number.isInteger(false); // false Number.isInteger([1]); // false //Когда точность числа превышает 53 двоичных бита, 54-й и последующие биты отбрасываются, что может привести к ошибочному суждению. Number.isInteger(1.0000000000000001) // true //Когда абсолютное значение числа меньше Number.MIN_VALUE (5E-324), то есть меньше наименьшего значения, которое может различить JavaScript, //оно автоматически преобразуется в 0, что также приводит к ошибочному суждению. Number.isInteger(5E-324); // false Number.isInteger(5E-325); // true Number.isSafeInteger()Используется для определения, находится ли число в безопасном диапазоне.Number.isSafeInteger(Number.MIN_SAFE_INTEGER - 1); // false Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1); // false

Расширения объекта Math

ES6 добавил 17 связанных с математикой статических методов в объект Math; эти методы можно вызывать только у Math.

Базовые вычисления

Math.cbrt

Используется для вычисления кубического корня числа.

Math.cbrt(1); // 1 Math.cbrt(0); // 0 Math.cbrt(-1); // -1 //Он преобразует значения, не являющиеся числами. Math.cbrt('1'); // 1 //Возвращает NaN для значений, не являющихся числами, которые невозможно преобразовать в числа. Math.cbrt('hhh'); // NaN

Math.imul

Результат умножения двух чисел как 32-битных знаковых целых; возвращаемое значение также является 32-битным знаковым целым.

//В большинстве случаев результат совпадает с a * b. Math.imul(1, 2); // 2 //Используется для корректного возврата младшего значения в результате умножения больших чисел. Math.imul(0x7fffffff, 0x7fffffff); // 1

Math.hypot

Используется для вычисления квадратного корня из суммы квадратов всех аргументов.

Math.hypot(3, 4); // 5 //Значения, не являющиеся числами, сначала преобразуются в числа перед вычислением. Math.hypot(1, 2, '3'); // 3.741657386773941 Math.hypot(true); // 1 Math.hypot(false); // 0 //Пустые значения преобразуются в 0. Math.hypot(); // 0 Math.hypot([]); // 0 //Возвращает Infinity, если аргумент равен Infinity или -Infinity. Math.hypot(Infinity); // Infinity Math.hypot(-Infinity); // Infinity //Возвращает NaN, если любой аргумент не может быть преобразован в число. Math.hypot(NaN); // NaN Math.hypot(3, 4, 'foo'); // NaN Math.hypot({}); // NaN

Math.clz32

Используется для возврата количества ведущих нулевых битов в 32-битном беззнаковом целочисленном представлении числа.

Math.clz32(0); // 32 Math.clz32(1); // 31 Math.clz32(0b01000000000100000000000000000000); // 1 //Если аргумент — десятичное число, учитывается только целая часть. Math.clz32(0.5); // 32 //Для пустых значений или нечисловых значений они преобразуются в числа перед вычислением. Math.clz32('1'); // 31 Math.clz32(); // 32 Math.clz32([]); // 32 Math.clz32({}); // 32 Math.clz32(NaN); // 32 Math.clz32(Infinity); // 32 Math.clz32(-Infinity); // 32 Math.clz32(undefined); // 32 Math.clz32('hhh'); // 32

Обработка чисел

Math.trunc

Используется для возврата целой части числа.

Math.trunc(12.3); // 12 Math.trunc(12); // 12 //Даже если целая часть равна 0, знак всё равно определяется. Math.trunc(-0.5); // -0 Math.trunc(0.5); // 0 //Math.trunc преобразует значения, не являющиеся числами, в числа перед обработкой. Math.trunc("12.3"); // 12 //Возвращает NaN для пустых значений или когда преобразование в число невозможно. Math.trunc(); // NaN Math.trunc(NaN); // NaN Math.trunc("hhh"); // NaN Math.trunc("123.2hhh"); // NaN

Math.fround

Используется для получения 32-битного представления числа с плавающей запятой одинарной точности.

//Для целых чисел между минус 2 в 24-й степени и 2 в 24-й степени (исключая обе конечные точки) возвращаемый результат совпадает с аргументом. Math.fround(-(2**24)+1); // -16777215 Math.fround(2 ** 24 - 1); // 16777215 //Используется для преобразования 64-битного числа с плавающей запятой двойной точности в 32-битное число с плавающей запятой одинарной точности. Math.fround(1.234) // 1.125 //Когда точность десятичного числа превышает 24 двоичных бита, точность теряется. Math.fround(0.3); // 0.30000001192092896 //Возвращает сам аргумент, когда он равен NaN или Infinity. Math.fround(NaN) // NaN Math.fround(Infinity) // Infinity //Когда аргумент имеет другой нечисловой тип, он преобразуется. Math.fround('5'); // 5 Math.fround(true); // 1 Math.fround(null); // 0 Math.fround([]); // 0 Math.fround({}); // NaN

Определение знака

Math.sign

Определяет знак числа (положительный, отрицательный или нулевой).

Math.sign(1); // 1 Math.sign(-1); // -1 //Когда аргумент равен 0, разные знаки возвращают разные результаты. Math.sign(0); // 0 Math.sign(-0); // -0 //Нечисловые значения преобразуются перед проверкой. Math.sign('1'); // 1 Math.sign('-1'); // -1 //Возвращает NaN, когда аргумент является нечисловым значением (которое не может быть преобразовано в число). Math.sign(NaN); // NaN Math.sign('hhh'); // NaN

Методы логарифмов

Math.expm1()

Используется для вычисления e в степени x минус 1, то есть Math.exp(x) - 1.

Math.expm1(1); // 1.718281828459045 Math.expm1(0); // 0 Math.expm1(-1); // -0.6321205588285577 //Преобразует нечисловые значения. Math.expm1('0'); //0 //Возвращает NaN, когда аргумент не является числом и не может быть преобразован в число. Math.expm1(NaN); // NaN

Math.log1p(x)

Используется для вычисления натурального логарифма 1 + x, то есть Math.log(1 + x).

Math.log1p(1); // 0.6931471805599453 Math.log1p(0); // 0 Math.log1p(-1); // -Infinity //Возвращает NaN, когда аргумент меньше -1. Math.log1p(-2); // NaN

Math.log10(x)

Используется для вычисления десятичного логарифма x.

Math.log10(1); // 0 //Значения, не являющиеся числами, преобразуются перед вычислением. Math.log10('1'); // 0 //Возвращает -Infinity, когда аргумент равен 0. Math.log10(0); // -Infinity //Возвращает NaN, когда аргумент меньше 0 или когда аргумент не является числом (и не может быть преобразован в число). Math.log10(-1); // NaN

Math.log2()

Используется для вычисления логарифма по основанию 2 от x.

Math.log2(1); // 0 //Значения, не являющиеся числами, преобразуются перед вычислением. Math.log2('1'); // 0 //Возвращает -Infinity, когда аргумент равен 0. Math.log2(0); // -Infinity //Возвращает NaN, когда аргумент меньше 0 или когда аргумент не является числом (и не может быть преобразован в число). Math.log2(-1); // NaN

Методы гиперболических функций

Math.sinh(x): используется для вычисления гиперболического синуса.
Math.cosh(x): используется для вычисления гиперболического косинуса.
Math.tanh(x): используется для вычисления гиперболического тангенса.
Math.asinh(x): используется для вычисления обратного гиперболического синуса.
Math.acosh(x): используется для вычисления обратного гиперболического косинуса.
Math.atanh(x): используется для вычисления обратного гиперболического тангенса.

Оператор возведения в степень

1 ** 2; // 1 //Правоассоциативный, вычисляется справа налево. 2 ** 2 ** 3; // 256 // **= let exam = 2; exam ** = 2; // 4