ES6 数值的扩展

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

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

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

如果要使用0b0o前缀的字符串转为十进制数值,要使用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

这两个新方法和传统的isFiniteisNaN的区别在于,传统方法先调用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将全局方法parseIntparseFloat移植到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内部,整数和浮点数都是同样的存储方式,33.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能够准确表示整数范围在(-253~253)内的数,超过这个范围就无法精确表示。ES6引入Number.MAX_SAFE_INTEGERNumber.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返回ex-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的精度限制,超过253的值无法精确表示。

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

你可能感兴趣的:(ES6 数值的扩展)