ES6-数值的扩展-Math对象的扩展

最新推荐文章于 2022-01-23 14:38:03 发布

宋极北

最新推荐文章于 2022-01-23 14:38:03 发布

阅读量322

点赞数

分类专栏： ES6 文章标签： ES6 扩展函数

ES6 专栏收录该内容

62 篇文章 1 订阅

订阅专栏

ES6 在 Math 对象上新增了17个与数学相关的方法，所有这些方法都是静态方法，只能在 Math 对象上调用。

Math.trunc()

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

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

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

Math.trunc('123.456') // 123
Math.trunc(true) //1
Math.trunc(false) // 0
Math.trunc(null) // 0

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

Math.trunc(NaN);      // NaN
Math.trunc('foo');    // NaN
Math.trunc();         // NaN
Math.trunc(undefined) // NaN

Math.sign()

Math.sign() 方法用来判断一个数到底是正数、负数、还是零。对于非数值，会先将其转为数值。

它会返回五种值：

参数为正数，返回 +1；

参数为负数，返回 -1；

参数为0，返回 0；

参数为 -0，返回 -0；

其他值，返回 NaN。

Math.sign(-5) // -1
Math.sign(5) // +1
Math.sign(0) // +0
Math.sign(-0) // -0
Math.sign(NaN) // NaN

如果参数是非数值，会自动转为数值，对于那些无法转为数值的值，会返回 NaN。

Math.sign('')  // 0
Math.sign(true)  // +1
Math.sign(false)  // 0
Math.sign(null)  // 0
Math.sign('9')  // +1
Math.sign('foo')  // NaN
Math.sign()  // NaN
Math.sign(undefined)  // NaN

对于没有部署这个方法的环境，可以用下面的代码模拟。

Math.sign = Math.sign || function(x) {
  x = +x; // convert to a number
  if (x === 0 || isNaN(x)) {
    return x;
  }
  return x > 0 ? 1 : -1;
};

Math.cbrt()

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

Math.cbrt(-1) // -1
Math.cbrt(0)  // 0
Math.cbrt(1)  // 1
Math.cbrt(2)  // 1.2599210498948734

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

Math.cbrt('8') // 2
Math.cbrt('hello') // NaN

对于没有部署这个方法的环境，可以用下面的代码模拟。

Math.cbrt = Math.cbrt || function (x) {
	var y = Math.pow(Math.abs(x), 1/3);
	return x<0 ? -y:y;
};

Math.clz32()

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

Math.clz32(0) // 32
Math.clz32(1) // 31
Math.clz32(1000) // 22
Math.clz32(0b01000000000000000000000000000000) // 1
Math.clz32(0b00100000000000000000000000000000) // 2

上面代码中，0 的二进制形式全为0，所以前面有 32 个0；1 二进制形式是 0b1，只占1位，所以32位之中前31个都是0；1000的二进制形式是 0b1111101000，一共有10位，所以32位之中前22位都是0。

clz32这个函数名就来自”count leading zero bits in 32-bit binary representations of a number“（计算32位整数的前导0）的缩写。

左移运算符（<<）与 Math.clz32 方法直接相关。

Math.clz32(0) // 32
Math.clz32(1) // 31
Math.clz32(1 << 1) // 30
Math.clz32(1 << 2) // 29
Math.clz32(1 << 29) // 2

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

Math.clz32(3.2) // 30
Math.clz32(3.9) // 30

对与空值或其他类型的值，Math.clz32 方法会将它们先转为数值，然后再计算。

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

Math.imul()

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

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

如果只考虑最后32位，大多数情况下，Math.imul(a,b) 与 a*b 的结果是相同的，即该方法等同于 (a*b)|0 的效果（超出32位的部分溢出）。之所以需要部署这个方法，是因为 JavaScript 有精度限制，超过2的53次方的值无法精确表示，也就是说，对于那些很大的数的乘法，低位数值往往都不是精确的，Math.imul 方法可以返回正确的低位数值。

(0x7fffffff * 0x7fffffff)|0 // 0

上面这个乘法算式，返回结果为0。但是由于这两个二进制数的最低位都是1，所以这个结果肯定是不正确的，因为根据二进制乘法，计算结果的二进制最低位应该也是1。这个错误就是因为它们的乘积超过了2的53次方，JavaScript无法保存额外的精度，就把低位的值都变成了0。Math.imul方法可以返回正确的值1。

Math.imul(0x7fffffff, 0x7fffffff) // 1

Math.hypot()

Math.hypot() 方法返回所以参数的平方和的平方根。

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

上面代码中，3的平方加上4的平方，等于5的平方。

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

对数方法

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

1） Math.expm1()

Math.expm1(x) 返回ex -1，即 Math.exp(x)-1。

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

对于没有部署这个方法的环境，可以用下面的代码模拟。

Math.expm1 = Math.expm1 || function(x) {
  return Math.exp(x) - 1;
};

2） 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 || function(x) {
  return Math.log(x) / Math.LN10;
};

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

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

对于没有部署这个方法的环境，可以用下面的代码模拟。

Math.log10 = Math.log10 || function(x) {
  return Math.log(x) / Math.LN10;
};

4） Math.log2()

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

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

对于没有部署这个方法的环境，可以用下面的代码模拟。

Math.log2 = Math.log2 || function(x) {
  return Math.log(x) / Math.LN2;
};

双曲函数方法

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)

Math.signbit()
Math.sign() 用来判断一个值的正负，但是如果参数是 -0，它会返回 -0。

Math.sign(-0) // -0

这导致对于判断符号位的正负，Math.sign() 不是很有用，JavaScript 内部使用64位浮点数（国际标准IEEE 754）表示数值，IEEE 754 规定的第一位是符号位，0表示正数，1表示负数。所以会有两种0，+0是符号为为0时的零值，-0是符号位为1时的零值。实际编程中，判断一个值是 +0 还是 -0 非常麻烦，因为它们是相等的。

+0 === -0 // true

目前有一个提案，引入Math.signbit() 方法判断一个数的发号位是否设置了。

Math.signbit(2) //false
Math.signbit(-2) //true
Math.signbit(0) //false
Math.signbit(-0) //true

可以看到，该方法正确返回了 -0 的符号位是设置了的。

该方法的算法如下。

如果参数是 -0，返回 true
如果参数是赋值，返回 true
如果参数是 NaN，返回 false
其他情况返回 false

指数运算符

ES6 新增了一个指数运算符（**）。

2 ** 2 // 4
2 ** 3 // 8

指数运算符可以与等号结合，形成一个新的赋值运算符（**=）.

let a = 1.5;
a **= 2;
// 等同于 a = a * a;

let b = 4;
b **= 3;
// 等同于 b = b * b * b;

注：在 V8 引擎中，指数运算符与 Math.pow() 的实现不相同，对于特别大的运算结果，两者会有细微的差异。

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

99 ** 99
// 3.697296376497268e+197

上面代码中，两个运算解构的最后一位有效数字是由差异的。

Integer 数据类型

1）JavaScript 所有数字都保存成64位浮点数，这决定了整数的精确程度只能到53个二进制，大于这个范围的整数，JavaScript 是无法精确表示的，这使得 JavaScript 不适合进行科学和金融方面的精确计算。

现在引入了新的数据类型 Integer(整数)，来解决这个问题，整数类型的数据只用来表示整数，没有位数的限制，任何位数的整数都可以精确表示。

为了与Number类型区别，Integer 类型的数据必须使用后缀 n 表示。

1n + 2n // 3n

二进制、八进制、十六进制的表示法，都要加上后缀 n。

0b1101n // 二进制
0o777n // 八进制
0xFFn // 十六进制

typeof 运算符对于 Integer 类型的数据返回 integer。

typeof 123n
// 'integer'

JavaScript 原生提供Integer 对象，用来生成 Integer 类型的数值，转换规则基本与 Number() 一致。

Integer(123) // 123n
Integer('123') // 123n
Integer(false) // 0n
Integer(true) // 1n

一下用法会报错。

new Integer() // TypeError
Integer(undefined) //TypeError
Integer(null) // TypeError
Integer('123n') // SyntaxError
Integer('abc') // SyntaxError

2）在运算方面，Integer 类型的 +、-、*和**这四个二元运算符，与 Number 类型的行为一致。除法运算符 / 会舍去小数部分，返回一个整数。

9n / 5n
// 1n

几乎所有的 Number 运算符都可以用在 Integer，但是有两个除外：不带符号的右移位运算符>>>和一元的求正运算符+，使用时会报错。前者是因为>>>要求最高位补0，但是 Integer 类型没有最高位，导致这个运算符无意义。后者是因为一元运算符+在 asm.js 里面总是返回 Number 类型或者报错。

Integer 类型不能与 Number 类型进行混合运算。

1n + 1
// 报错

这是因为无论返回的是 Integer 或 Number，都会导致丢失信息。比如(2n**53n + 1n) + 0.5这个表达式，如果返回 Integer 类型，0.5这个小数部分会丢失；如果返回 Number 类型，会超过 53 位精确数字，精度下降。
相等运算符（==）会改变数据类型，也是不允许混合使用。

0n == 0
// 报错 TypeError

0n == false
// 报错 TypeError

精确相等运算符（===）不会改变数据类型，因此可以混合使用。

0n === 0
// false

宋极北

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
ES6-数值的扩展-Math对象的扩展

ES6 在 Math 对象上新增了17个与数学相关的方法，所有这些方法都是静态方法，只能在 Math 对象上调用。Math.trunc()Math.trunc() 方法用于去除一个数的小数部分，返回整数部分。 Math.trunc(4.1) // 4Math.trunc(4.9) // 4Math.trunc(-4.1) // -4Math.trunc(-4.9) // -...
复制链接

扫一扫