ES6+ Math 對象的擴展

1. 前言

在編程中遇到數(shù)學問題時一般會借助 Math 這個 JavaScript 的內置對象，它擁有一些數(shù)學常數(shù)屬性和數(shù)學函數(shù)方法。Math 不是一個函數(shù)對象，它主要用于 Number 類型。

與其他全局對象不同的是，Math 不是一個構造器。Math 的所有屬性與方法都是靜態(tài)的。比如：

• 圓周率的寫法是 Math.PI，
• 調用正余弦函數(shù)的寫法是 Math.sin(x)，x 是要傳入的參數(shù)。

Math 的常量是使用 JavaScript 中的全精度浮點數(shù)來定義的。本節(jié)我們主要學習，ES6 對 Math 對象的擴展。

2. Math.trunc

Math.trunc() 方法會將數(shù)字的小數(shù)部分去掉，只保留整數(shù)部分，是一個取整操作。

Math 中還有三個方法： Math.floor()、Math.ceil()、Math.round() ，也是用于取整操作的，但是他們有一定邏輯的：

• Math.floor() 向下取整；
• Math.ceil() 向上取整；
• Math.round() 進行四舍五入操作。

相比之下 Math.trunc() 的執(zhí)行邏輯就很簡單，僅僅是刪除掉數(shù)字的小數(shù)部分和小數(shù)點，不管參數(shù)是正數(shù)還是負數(shù)。

使用語法：

Math.trunc(value)

參數(shù)說明：

實例

基本實例：

Math.trunc(5.3) // 5
Math.trunc(5.9) // 5
Math.trunc(-5.3) // -5
Math.trunc(-5.9) // -5
Math.trunc(-0.12345) // -0

上面的代碼中，第 5 行雖然結果是 0 但是 0 前面的負號還會被保留。

傳入該方法的參數(shù)會被隱式轉換成數(shù)字類型，也就是對于非數(shù)值，Math.trunc() 內部使用 Number() 方法將其先轉為數(shù)值。

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

對于空值和無法截取整數(shù)的值，返回 NaN。

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

3. Math.sign()

Math.sign() 方法用來判斷一個數(shù)到底是正數(shù)、負數(shù)、還是零。對于非數(shù)值，會先將其轉換為數(shù)值。

使用語法：

Math.sign(value)

參數(shù)說明：

Math.sign() 會返回五種值。

• 參數(shù)為正數(shù)，返回 + 1；
• 參數(shù)為負數(shù)，返回 - 1；
• 參數(shù)為 0，返回 0；
• 參數(shù)為 - 0，返回 - 0;
• 其他值，返回 NaN。

實例

Math.sign(7); // 1
Math.sign(-7.5); // -1
Math.sign("-7.5"); // -1
Math.sign(0); // 0
Math.sign(-0); // -0

對應 -0 轉換后的結果會保留負號，如果參數(shù)是非數(shù)值，會自動轉為數(shù)值。對于那些無法轉換為數(shù)值的值，會返回 NaN。

Math.sign(NaN); // NaN
Math.sign("foo"); // NaN
Math.sign(); // NaN

4 Math.cbrt()

Math.cbrt() 函數(shù)返回任意數(shù)字的立方根。cbrt 是 “cube root” 的縮寫，意思是立方根.

使用語法：

Math.cbrt(value)

參數(shù)說明：

對于非數(shù)值，Math.cbrt() 方法內部也是先使用 Number 方法將其轉為數(shù)值。無法轉換為數(shù)值的返回 NaN。

實例：

Math.cbrt('8'); // 2
Math.cbrt('imooc'); // NaN
Math.cbrt(NaN); // NaN
Math.cbrt(-1); // -1
Math.cbrt(-0); // -0
Math.cbrt(-Infinity); // -Infinity
Math.cbrt(0); // 0
Math.cbrt(1); // 1
Math.cbrt(Infinity); // Infinity
Math.cbrt(null); // 0
Math.cbrt(2); // 1.2599210498948734

5. Math.clz32()

JavaScript 的整數(shù)使用 32 位二進制表示，Math.clz32() 方法返回一個數(shù)的 32 位無符號整數(shù)形式有多少個前導 0。

使用語法：

Math.clz32(value)

參數(shù)說明：

Math.clz32() 函數(shù)返回一個數(shù)字在轉換成 32 無符號整形數(shù)字的二進制形式后，開頭的 0 的個數(shù)，比如 1000000 轉換成 32 位無符號整形數(shù)字的二進制形式后是 00000000000011110100001001000000, 開頭的 0 的個數(shù)是 12 個，則 Math.clz32(1000000) 返回 12.

實例：

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

左移運算符（<<）與 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

對于小數(shù)，Math.clz32 方法只考慮整數(shù)部分。

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

對于空值或其他類型的值，Math.clz32 方法會將它們先轉為數(shù)值，然后再計算。無法轉換為數(shù)值的按照 0 來算。

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

6. Math.imul()

Math.imul() 方法返回兩個數(shù)以 32 位帶符號整數(shù)形式相乘的結果，返回的也是一個 32 位的帶符號整數(shù)。

使用語法：

Math.imul(a, b)

參數(shù)說明：

如果只考慮最后 32 位，大多數(shù)情況下，Math.imul(a, b) 與 a * b 的結果是相同的，即該方法等同于 (a * b)|0 的效果（超過 32 位的部分溢出）。

之所以需要部署這個方法，是因為 JavaScript 有精度限制，超過 2 的 53 次方的值無法精確表示。這就是說，對于那些很大的數(shù)的乘法，低位數(shù)值往往都是不精確的，Math.imul 方法可以返回正確的低位數(shù)值。

實例：

Math.imul() // 0
Math.imul(3, 5) // 15
Math.imul(-1, 5) // -5
Math.imul(1, -5) // -5
Math.imul(-2, -2) // 4
Math.imul(2.9, 4.5) // 8
Math.imul(0.9, 5) // 0
Math.imul(true, 5) // 1
Math.imul(NaN, 5) // 0

這里注意的是，Math.imul() 方法接收的參數(shù)是整數(shù)，如果參數(shù)是浮點數(shù)則會調用 Math.trunc() 把小數(shù)點后面的數(shù)字去掉，然后再相乘。如果不能被轉換則統(tǒng)一返回 0。

7. Math.fround()

Math.fround() 方法返回一個數(shù)的 32 位單精度浮點數(shù)形式。

使用語法：

Math.fround(doubleFloat)

參數(shù)說明：

對于 32 位單精度格式來說，數(shù)值精度是 24 個二進制位（1 位隱藏位與 23 位有效位），所以對于 -224 至 224 之間的整數(shù)（不含兩個端點），返回結果與參數(shù)本身一致。

實例：

Math.fround(0) // 0
Math.fround(1) // 1
Math.fround(2 ** 24 - 1) // 16777215

如果參數(shù)的絕對值大于 224，返回的結果便開始丟失精度。

Math.fround(2 ** 24) // 16777216
Math.fround(2 ** 24 + 1) // 16777216

Math.fround() 方法的主要作用，是將 64 位雙精度浮點數(shù)轉為 32 位單精度浮點數(shù)。如果小數(shù)的精度超過 24 個二進制位，返回值就會不同于原值，否則返回值不變（即與 64 位雙精度值一致）。

// 未丟失有效精度
Math.fround(1.125) // 1.125
Math.fround(7.25) // 7.25

// 丟失精度
Math.fround(0.3) // 0.30000001192092896
Math.fround(0.7) // 0.699999988079071
Math.fround(1.0000000123) // 1

對于 NaN 和 Infinity，此方法返回原值。對于其它類型的非數(shù)值，Math.fround() 方法會先將其轉為數(shù)值，再返回單精度浮點數(shù)。

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

8. Math.hypot()

Math.hypot 方法返回所有參數(shù)的平方和的平方根。

使用語法：

Math.hypot([value1[,value2, ...]])

參數(shù)說明：

如果參數(shù)不是數(shù)值，Math.hypot 方法會將其轉換為數(shù)值。只要有一個參數(shù)無法轉換為數(shù)值，就會返回 NaN。

實例：

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

9. 對數(shù)方法

9.1 Math.expm1()

Math.expm1(x) 函數(shù)返回 E^x - 1，其中 x 是該函數(shù)的參數(shù)， E 是自然對數(shù)的底數(shù) 2.718281828459045。

使用語法：

Math.expm1(x)

參數(shù)說明：

實例：

Math.expm1(1) // 1.718281828459045
Math.expm1(0) // 0
Math.expm1(-1) // -0.6321205588285577
Math.expm1(-37) // -0.9999999999999999
Math.expm1(-38) // -1
Math.expm1(-88) // -1
Math.expm1("-38") // -1
Math.expm1("foo") // NaN

9.2 Math.log1p()

Math.log1p(x) 函數(shù)返回 1 + x 的自然對數(shù) (底為 E)，即 Math.log(1 + x)。如果 x 小于 -1，返回 NaN。

使用語法：

Math.log1p(x)

參數(shù)說明：

實例：

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

9.3 Math.log10()

Math.log10(x) 函數(shù)返回以 10 為底的 x 的對數(shù)。如果 x 小于 0，則返回 NaN。

使用語法：

Math.log10(x)

參數(shù)說明：

實例：

Math.log10(10) // 1
Math.log10(100000) // 5
Math.log10("100")// 2
Math.log10(0) // -Infinity
Math.log10(1) // 0
Math.log10(2) // 0.3010299956639812
Math.log10(-2) // NaN
Math.log10("imooc")// NaN

9.4 Math.log2()

Math.log2 (x) 返回以 2 為底的 x 的對數(shù)。如果 x 小于 0，則返回 NaN。

使用語法：

Math.log2(x)

參數(shù)說明：

實例：

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("1024") // 10
Math.log2(1 << 29) // 29
Math.log2("imooc") // NaN

10. 冪運算符

ES2016 新增了一個冪運算符 ** （也可以說是指數(shù)運算符）。冪運算符返回第一個操作數(shù)作底數(shù)，第二個操作數(shù)作指數(shù)的乘方。即，var1^var2，其中 var1 和 var2 是其兩個操作數(shù)。冪運算符是右結合的。a ** b ** c 等同于 a ** (b ** c)。

3 ** 2 // 9
3 ** 3 // 27

指數(shù)運算符可以與等號結合，形成一個新的賦值運算符（**=）。

let a = 1.5;
a **= 2;
// 等同于 a = a * a;
let b = 4;
b **= 3;
// 等同于 b = b * b * b;

指數(shù)運算符與 Math.pow() 基本相同，不過使用冪運算符更加方便簡潔。

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

11. 小結

本節(jié)主要介紹了 ES6 對 Math 這個對象的擴展，ES6 主要豐富了更多的數(shù)學方法，讓我們更好地處理數(shù)學問題。