ES6 数值的扩展

二进制和八进制数值表示法

ES6提供了二进制和八进制的新写法，分别用前缀0b（或0B）和0o（或0O）表示。

console.log(0b111110111 === 503); // true
console.log(0o767 === 503); // true

如果要使用0b或0o前缀的字符串转为十进制数值，要使用Number方法

Number.isFinite, Number.isNaN

Number.isFinite用来检查一个数值是否非无穷（Infinity全局属性，是一个数值，表示无穷大）

console.log(Number.isFinite(15)); // true
console.log(Number.isFinite(0.8)); // true
console.log(Number.isFinite(NaN)); // false
console.log(Number.isFinite(Infinity)); // false
console.log(Number.isFinite(-Infinity)); // 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(15)); // false
console.log(Number.isNaN('15')); // false
console.log(Number.isNaN(true)); // false
console.log(Number.isNaN(9 / NaN)); // true
console.log(Number.isNaN('true' / 0)); // true
console.log(Number.isNaN('true' / 'true')); // true

这两个新方法和传统的isFinite和isNaN的区别在于，传统方法先调用Number将非数值转为数值，再进行判断，而新方法只对数值有效，对非数值一律返回false

console.log(isFinite(25)); // true
console.log(isFinite('25')); // true
console.log(Number.isFinite(25)); // true
console.log(Number.isFinite('25')); // false

console.log(isNaN(NaN)); // true
console.log(isNaN('NaN')); // true
console.log(Number.isNaN(NaN)); // true
console.log(Number.isNaN('NaN')); // false

Number.parseInt, Number.parseFloat

ES6将全局方法parseInt和parseFloat移植到Number对象上，行为保持不变。这样做的目的，是逐步减少全局性方法，使语言逐步模块化。

console.log(parseInt('12.34')); // 12
console.log(parseFloat('123.45#')); // 123.45

console.log(Number.parseInt('12.34')); // 12
console.log(Number.parseFloat('123.45#')); // 123.45

console.log(Number.parseInt === parseInt); // true
console.log(Number.parseFloat === parseFloat); // true

Number.isInteger

Number.isInteger用来判断一个值是否为整数。需要注意的是JavaScript内部，整数和浮点数都是同样的存储方式，3和3.0被视为同一个值。

console.log(Number.isInteger(25)); // true
console.log(Number.isInteger(25.0)); // true
console.log(Number.isInteger(25.1)); // false
console.log(Number.isInteger('15')); // false
console.log(Number.isInteger(true)); // false

Number.EPSILON

ES6在Number对象上新增了一个极小的常量——Number.EPSILON[ˈepsɪlɑːn]，目的在于为浮点数计算设置一个误差范围。因为浮点数计算是不精确的，但是如果这个误差能够小于Number.EPSILON，就可以认为得到了正确的结果。

console.log(Number.EPSILON); // 2.220446049250313e-16
// toFixed() 方法可把 Number 四舍五入为指定小数位数的数字。
console.log(Number.EPSILON.toFixed(20)); // 0.00000000000000022204

console.log(0.1 + 0.2); // 0.30000000000000004
console.log(0.1 + 0.2 - 0.3); // 5.551115123125783e-17
console.log((0.1 + 0.2 - 0.3).toFixed(20)); // 0.00000000000000005551
console.log((0.1 + 0.2 - 0.3) < Number.EPSILON); // true

Number.EPSILON的实质是一个可以接受的误差范围。

安全整数和Number.isSafeInteger

JavaScript能够准确表示整数范围在(-2⁵³~2⁵³)内的数，超过这个范围就无法精确表示。ES6引入Number.MAX_SAFE_INTEGER和Number.MIN_SAFE_INTEGER两个常量，用来表示这个范围的上下限。

console.log(Math.pow(2, 53)); // 9007199254740992
console.log(Math.pow(2, 53) === (Math.pow(2, 53) + 1)); // true
console.log(9007199254740992); // 9007199254740992
console.log(9007199254740993); // 9007199254740992

console.log(Number.MAX_SAFE_INTEGER === -Number.MIN_SAFE_INTEGER); // true
console.log(Number.MIN_SAFE_INTEGER === -9007199254740991); // true

Number.isSafeInteger用来判断一个整数是否落在这个范围内。

console.log(Number.isSafeInteger('a')); // false
console.log(Number.isSafeInteger(null)); // false
console.log(Number.isSafeInteger(NaN)); // false
console.log(Number.isSafeInteger(Infinity)); // false
console.log(Number.isSafeInteger(-Infinity)); // false

console.log(Number.isSafeInteger(3)); // true
console.log(Number.isSafeInteger(1.2)); // false
console.log(Number.isSafeInteger(9007199254740990)); // true
console.log(Number.isSafeInteger(9007199254740992)); // false

console.log(Number.isSafeInteger(Number.MIN_SAFE_INTEGER)); // true
console.log(Number.isSafeInteger(Number.MIN_SAFE_INTEGER - 1)); // false
console.log(Number.isSafeInteger(Number.MAX_SAFE_INTEGER)); // true
console.log(Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1)); // false

验证运算结果是否落在安全整数范围内，不只要验证运算结果，而且同时要验证参与运算的每个值。

console.log(Number.isSafeInteger(9007199254740993)); // false
console.log(Number.isSafeInteger(900)); // true
console.log(Number.isSafeInteger((9007199254740993 - 900))); // true

Math对象的扩展

ES6在Math对象上新增了17个与数学相关的方法。

Math.trunc

Math.trunc方法用于去除一个数的小数部分，返回整数部分

console.log(Math.trunc(4.1)); // 4
console.log(Math.trunc(4.9)); // 4
console.log(Math.trunc(-4.1)); // -4
console.log(Math.trunc(-4.9)); // -4
console.log(Math.trunc(-0.1234)); // -0

对于非数值，Math.trunc内部使用Number方法将其转为数值

console.log(Math.trunc('123.456')); // 123

对于空值和无法截取整数的值，返回NaN

console.log(Math.trunc(NaN)); // NaN
console.log(Math.trunc('foo')); // NaN
console.log(Math.trunc()); // NaN

Math.sign

Math.sign方法用于判断一个数到底是正数、负数还是零。其返回值有5种情况：

• 参数为正数，返回+1
• 参数为负数，fanhui-1
• 参数为0，返回0
• 参数为-0，返回 -0
• 其他值，返回NaN

console.log(Math.sign(5)); // 1
console.log(Math.sign(-5)); //-1
console.log(Math.sign(0)); // 0
console.log(Math.sign(-0)); // -0
console.log(Math.sign(NaN)); // NaN
console.log(Math.sign('foo')); // NaN
console.log(Math.sign()); // NaN

Math.cbrt

Math.cbrt方法用于计算一个数的立方根

console.log(Math.cbrt(-1)); // -1
console.log(Math.cbrt(0)); // 0
console.log(Math.cbrt(1)); // 1
console.log(Math.cbrt(2)); // 1.2599210498948732

对于非数值，Math.cbrt方法内部也会先使用Number方法将其转为数值

console.log(Math.cbrt('8')); // 2
console.log(Math.cbrt('hello')); // NaN

Math.hypot

Math.hypot方法返回所有参数的平方和的平方根

console.log(Math.hypot(3, 4)); // 5
console.log(Math.hypot(3, 4, 5)); // 7.0710678118654755
console.log(Math.hypot()); // 0
console.log(Math.hypot(NaN)); // NaN
console.log(Math.hypot(3, 4, 'foo')); // NaN
console.log(Math.hypot(3, 4, '5')); // 7.0710678118654755
console.log(Math.hypot(-3)); // 3

如果参数不是数值，Math.hypot方法会将其转换为数值。只要有一个参数无法转换为数值，就会返回NaN

Math.fround

Math.fround方法返回一个数的单精度浮点数形式

console.log(Math.fround(0)); // 0
console.log(Math.fround(1)); // 1
console.log(Math.fround(1.337)); // 1.3370000123977661
console.log(Math.fround(1.5)); // 1.5
console.log(Math.fround(NaN)); // NaN

对于整数来说，Math.fround方法返回结果不会有任何不同，区别主要是在于那些无法用64个二进制位精确表示的小数。这时，Math.fround方法返回最接近这个小数的单精度浮点数。

对数方法

ES6新增了4个对数相关的方法

Math.expm1

Math.expm1返回e^x-1，即Math.expm(x)-1

console.log(Math.expm1(1)); // 1.718281828459045
console.log(Math.expm1(0)); // 0
console.log(Math.expm1(-1)); // -0.6321205588285577

Math.log1p

Math.log1p(x)返回1 + x的自然对数，即Math.log(1+x)。如果x小于-1，则返回NaN

console.log(Math.log1p(1)); // 0.6931471805599453
console.log(Math.log1p(0)); // 0
console.log(Math.log1p(-1)); // -Infinity
console.log(Math.log1p(-2)); // NaN

Math.log10

Math.log10(x)返回以10为底的x的对数，如果小于0，则返回NaN

console.log(Math.log10(2)); // 0.3010299956639812
console.log(Math.log10(1)); // 0
console.log(Math.log10(0)); // -Infinity
console.log(Math.log10(-2)); // NaN
console.log(Math.log10(100000)); // 5

Math.log2

Math.log2(x)返回以2为底的x的对数，如果小于0，则返回NaN

console.log(Math.log2(3)); // 1.584962500721156
console.log(Math.log2(2)); // 1
console.log(Math.log2(1)); // 0
console.log(Math.log2(0)); // -Infinity
console.log(Math.log2(-2)); //NaN
console.log(Math.log2(1024)); //10
console.log(Math.log2(1 << 29)); // 29

Math.imul

Math.imul方法返回两个数以32位带符号整数形式相乘的结果，返回的也是一个32位的带符号整数

console.log(Math.imul(2, 4)); // 8
console.log(Math.imul(-1, 8)); // -8
console.log(Math.imul(-2, -2)); // 4

如果只考虑最后32位，大多数情况下，Math.imul(a, b)和a * b的结果是相同的，之所以需要这个方法，是因为JavaScript的精度限制，超过2⁵³的值无法精确表示。

Math.clz32

JavaScript的整数使用32位二进制形式表示，Math.clz32方法返回一个数的32位无符号整数形式有多少个前导0

console.log(Math.clz32(0)); // 32
console.log(Math.clz32(1)); // 31
console.log(Math.clz32(1000)); // 22
console.log(Math.clz32(0b0100000000000000000000000000000)); // 2
console.log(Math.clz32(0b0010000000000000000000000000000)); // 3

对于小数，Math.clz32方法只考虑整数部分

console.log(Math.clz32(3.2)); // 32
console.log(Math.clz32(13.9)); // 28

对于空值或其他类型的值，Math.clz32方法会将其先转为数值，再计算

console.log(Math.clz32()); // 32
console.log(Math.clz32(NaN)); // 32
console.log(Math.clz32(Infinity)); // 32
console.log(Math.clz32(null)); // 32
console.log(Math.clz32('foo')); // 32
console.log(Math.clz32([])); // 32
console.log(Math.clz32({})); // 32
console.log(Math.clz32(true)); // 31

三角函数方法

ES6新增的6个三角函数方法

• Math.sinh(x)： 返回x的双曲正弦（hyperbolic sine）
• Math.cosh(x)：返回x的双曲余弦（hyperbolic cosine）
• Math.tanh(x)：返回x的双曲正切（hyperbolic tangent）
• Math.asinh(x)：返回x的反双曲线正弦（inverse hyperbolic sine）
• Math.acosh(x)：返回x的反双曲线余弦（inverse hyperbolic cosine）
• Math.atanh(x)：返回x的反双曲正切（inverse hyperbolic tangent）

指数运算符

ES6新增了一个指数运算符（**），指数运算符可以和等号结合，形成一个新的赋值运算符（**=）。

console.log(2 ** 2); // 4
console.log(2 ** 3); // 8

let a = 2;
console.log(a **= 3); // 8