ES6类型扩展数字扩展

求幂运算符

在ES6之前通常使用Math.pow()方法执行求幂运算，ES6新引入了求幂运算符，用两个星号（**）表示，左操作数是基数，右操作数是指数。

console.log(5 ** 2) // 25
console.log(5 ** 2) === Math.pow(5,2)) // true

求幂运算符可以和等号结合，形成新的赋值运算符（**=）

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

注意： 在v8引擎中，求幂运算符和Math.pow()的实现是不同的，对于特别大的运算结果会有差异。

Math.pow(99, 99) // 3.697296376497263e+197
99 ** 99 // 3.697296376497268e+197

console.log(99 ** 99) === Math.pow(99,99)) // false

不同进制

ES6提供了二进制和八进制值的新的写法，二进制前缀用0b或0B，八进制前缀用0o或0O

0b11 === 3
0o3 === 3

Number方法

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

Number.parseInt === parseInt // true
Number.parseFloat === parseFloat // true

ES6为Number对象提供了Number.isFinite()和Number.isNaN()方法。Number.isFinite()判断一个数是否是有限的，Number.isNaN()判断一个数是否是NaN。

这两个方法跟全局的isFinite()和isNaN()方法有些不同，它们没有隐式Number()类型转换。

console.log(Number.isFinite(3)) // true
console.log(Number.isFinite('3')) // false 
console.log(Number.isFinite(true)) // false
console.log(Number.isFinite('bar')) // false
console.log(Number.isFinite(Infinity)) // false

console.log(Number.isNaN(NaN)) // true
console.log(Number.isNaN('3')) // false 
console.log(Number.isNaN(true)) // false
console.log(Number.isNaN('bar')) // false
console.log(Number.isNaN(Infinity)) // false

Number.isFinite()对非数值一律返回false。
Number.isNaN()对非NaN一律返回false。

ES6提供了Number.isInteger()方法，用于判断一个数是否是整数。需要注意的是JS不区分整型和浮点型数值。

console.log(Number.isInteger(3)) // true
console.log(Number.isInteger(3.0)) // true
console.log(Number.isInteger('3')) // false

Number常量

ES6为Number对象引入一个极小的常量Number.EPSILON，引入这个常量是为了便于进行浮点数运算时，设置一个允许的误差范围。

Number.EPSILON // 2.220446049250313e-16

0.1 + 0.2 - 0.3 < Number.EPSILON // true

在进行数值运算时，如果误差值小于Number.EPSILON，可以认为得到了正确的结果

function withinErrorMargin (left,right){
  return Math.abs(left - right) < Number.EPSILON
}

withinErrorMargin(0.1+0.2,0.3) // true
withinErrorMargin(0.11+0.2,0.3) // false

安全整数

JS能够准确表示的整数范围在-2^53到2^53之间（不含端点值），超过这个范围后无法精确表示这个值。

Math.pow(2, 53) === Math.pow(2, 53) + 1 // true

ES6引入了Number.MAX_SAFE_INTEGER和Number.MIN_SAFE_INTEGER这两个常量，用来表示这个范围的上下限

Number.MIN_SAFE_INTEGER === Math.pow(-2,53) + 1 // true
Number.MAX_SAFE_INTEGER === Math.pow(2,53) - 1 // true

Number.MIN_SAFE_INTEGER === -Number.MAX_SAFE_INTEGER // true

Number.isSafeInteger()则是用来判断一个整数是否是安全数。

实际使用该函数时，通常不仅要验证运算结果，参与运算的数值也要验证。

function trusty (left, right, result) {
  if (
    Number.isSafeInteger(left) &&
    Number.isSafeInteger(right) &&
    Number.isSafeInteger(result)
  ) {
    return result;
  }
  throw new RangeError('Operation cannot be trusted!');
}
// RangeError: Operation cannot be trusted!
trusty(9007199254740993, 990, 9007199254740993 - 990)

trusty(1, 2, 3)// 3

Math对象

ES6为Math对象新增了17个数学相关的静态方法。

Math.trunc()

Math.trunc()方法返回一个数的整数部分。非数值会隐式调用Number转型函数，如果无法截取整数值则返回NaN

console.log(Math.trunc(12.3)) // 12
console.log(Math.trunc(-12.3)) // -12
console.log(Math.trunc('12.3')) // 12
console.log(Math.trunc('bar')) // NaN
console.log(Math.trunc()) // NaN

Math.sign()

Math.sign()方法判断一个数是正数、负数、还是0。非数值会隐式调用Number转型函数。

参数为正数则返回+1，为负数则返回-1，为0则返回0，为-0则返回-0

console.log(Math.sign(-3)) // -1
console.log(Math.sign(3)) // +1
console.log(Math.sign(0)) // 0
console.log(Math.sign(-0)) // -0
console.log(Math.sign('3')) // +1
console.log(Math.sign(NaN)) // NaN
console.log(Math.sign('bar')) // NaN
console.log(Math.sign()) // NaN

Math.cbrt()

Math.cbrt()方法计算一个数的立方根。非数值会隐式调用Number转型函数。

console.log(Math.cbrt(-1)) // -1
console.log(Math.cbrt(0))  // 0
console.log(Math.cbrt(3))  // 1.4422495703074083
console.log(Math.cbrt('bar'))  // NaN
console.log(Math.cbrt())  // NaN

Math.clz32()

Math.clz32()方法返回一个数的32位无符号整数形式有多少前导0。非数值会隐式调用Number转型函数。如果是小数，该方法只考虑整数部分。

console.log(Math.clz32(0)) // 32
console.log(Math.clz32(1)) // 31
console.log(Math.clz32(3)) // 30
console.log(Math.clz32(3.1)) // 30
console.log(Math.clz32(null)) // 32
console.log(Math.clz32(true)) // 32
console.log(Math.clz32('bar')) // 32
console.log(Math.clz32()) // 32

Math.imul()

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

console.log(Math.imul(1,3)) // 3
console.log(Math.imul(-1,3)) // -3

Math.fround()

Math.fround()方法返回一个数的单精度浮点数形式。对于无法用64个二进制位精确表示的小数，该方法会返回最接近这个小数的单精度浮点数。

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

Math.hypot()

Math.hypot()方法返回所有参数平方和的平方根。非数值会隐式调用Number转型函数。

Math.hypot(3, 4);  // 5
Math.hypot('3', '4', '5');// 7.0710678118654755
Math.hypot(); // 0

ES6新增了4个和对数相关的方法: Math.expm1()、Math.log1p()、Math.log10()、Math.log2()

Math.expm1()

Math.expm1(x)方法返回e^x - 1。

Math.expm1(-1) // -0.6321205588285577
Math.expm1(0)  // 0
Math.expm1(1)  // 1.718281828459045

Math.log1p()

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

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

Math.log10()

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

Math.log10(100)      // 2
Math.log10(1)      // 0
Math.log10(0)      // -Infinity
Math.log10(-2)     // NaN

Math.log2()

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

Math.log2(8)       // 3
Math.log2(2)       // 1
Math.log2(1)       // 0
Math.log2(0)       // -Infinity
Math.log2(-2)      // NaN

双曲函数

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）