1.二進制和八進制表示法

ES6 提供了二進制和八進制數值的新的寫法，分别用字首0b（或0B）和0o（或0O）表示。

0b111110111 === 503 // true
0o767 === 503 // true

從 ES5 開始，在嚴格模式之中，八進制就不再允許使用字首0表示，ES6 進一步明确，要使用字首0o表示。

// 非嚴格模式
(function(){
  console.log(0o11 === 011);
})() // true

// 嚴格模式
(function(){
  'use strict';
  console.log(0o11 === 011);
})() // Uncaught SyntaxError: Octal literals are not allowed in strict mode.

如果要将0b和0o字首的字元串數值轉為十進制，要使用Number方法。

Number('0b111')  // 7
Number('0o10')  // 8

2.Number.isFinite(), Number.isNaN()

ES6 在Number對象上，新提供了Number.isFinite()和Number.isNaN()兩個方法。

Number.isFinite()用來檢查一個數值是否為有限的（finite），即不是Infinity。

Number.isFinite(15); // true
Number.isFinite(0.8); // true
Number.isFinite(NaN); // false
Number.isFinite(Infinity); // false
Number.isFinite(-Infinity); // false
Number.isFinite('foo'); // false
Number.isFinite('15'); // false
Number.isFinite(true); // false

注意，如果參數類型不是數值，Number.isFinite一律傳回false。

Number.isNaN()用來檢查一個值是否為NaN。

Number.isNaN(NaN) // true
Number.isNaN(15) // false
Number.isNaN('15') // false
Number.isNaN(true) // false
Number.isNaN(9/NaN) // true
Number.isNaN('true' / 0) // true
Number.isNaN('true' / 'true') // true

如果參數類型不是NaN，Number.isNaN一律傳回false。

3.Number.parseInt(), Number.parseFloat()

ES6 将全局方法parseInt()和parseFloat()，移植到Number對象上面，行為完全保持不變。

// ES5的寫法
parseInt('12.34') // 12
parseFloat('123.45#') // 123.45

// ES6的寫法
Number.parseInt('12.34') // 12
Number.parseFloat('123.45#') // 123.45

這樣做的目的，是逐漸減少全局性方法，使得語言逐漸子產品化。

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

4.Number.isInteger()

Number.isInteger()用來判斷一個數值是否為整數。

Number.isInteger(25) // true
Number.isInteger(25.1) // false

JavaScript 内部，整數和浮點數采用的是同樣的儲存方法，是以 25 和 25.0 被視為同一個值。

Number.isInteger(25) // true
Number.isInteger(25.0) // true

如果參數不是數值，Number.isInteger傳回false。

Number.isInteger() // false
Number.isInteger(null) // false
Number.isInteger('15') // false
Number.isInteger(true) // false

注意，由于 JavaScript 采用 IEEE 754 标準，數值存儲為64位雙精度格式，數值精度最多可以達到 53 個二進制位（1 個隐藏位與 52 個有效位）。如果數值的精度超過這個限度，第54位及後面的位就會被丢棄，這種情況下，Number.isInteger可能會誤判。

上面代碼中，Number.isInteger的參數明明不是整數，但是會傳回true。原因就是這個小數的精度達到了小數點後16個十進制位，轉成二進制位超過了53個二進制位，導緻最後的那個2被丢棄了。

類似的情況還有，如果一個數值的絕對值小于Number.MIN_VALUE（5E-324），即小于 JavaScript 能夠分辨的最小值，會被自動轉為 0。這時，Number.isInteger也會誤判。

Number.isInteger(5E-324) // false
Number.isInteger(5E-325) // true

上面代碼中，5E-325由于值太小，會被自動轉為0，是以傳回true。

總之，如果對資料精度的要求較高，不建議使用Number.isInteger()判斷一個數值是否為整數。

5.Number.EPSILON

ES6 在Number對象上面，新增一個極小的常量Number.EPSILON。根據規格，它表示 1 與大于 1 的最小浮點數之間的差。

對于 64 位浮點數來說，大于 1 的最小浮點數相當于二進制的1.00…001，小數點後面有連續 51 個零。這個值減去 1 之後，就等于 2 的 -52 次方。

Number.EPSILON === Math.pow(2, -52)
// true
Number.EPSILON
// 2.220446049250313e-16
Number.EPSILON.toFixed(20)
// "0.00000000000000022204"

Number.EPSILON實際上是 JavaScript 能夠表示的最小精度。誤差如果小于這個值，就可以認為已經沒有意義了，即不存在誤差了。

引入一個這麼小的量的目的，在于為浮點數計算，設定一個誤差範圍。我們知道浮點數計算是不精确的。

0.1 + 0.2
// 0.30000000000000004

0.1 + 0.2 - 0.3
// 5.551115123125783e-17

5.551115123125783e-17.toFixed(20)
// '0.00000000000000005551'

上面代碼解釋了，為什麼比較0.1 + 0.2與0.3得到的結果是false。

Number.EPSILON可以用來設定“能夠接受的誤差範圍”。比如，誤差範圍設為 2 的-50 次方（即Number.EPSILON * Math.pow(2, 2)），即如果兩個浮點數的差小于這個值，我們就認為這兩個浮點數相等。

5.551115123125783e-17 < Number.EPSILON * Math.pow(2, 2)
// true

是以，Number.EPSILON的實質是一個可以接受的最小誤差範圍。

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

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

1.1 + 1.3 === 2.4 // false
withinErrorMargin(1.1 + 1.3, 2.4) // true

上面的代碼為浮點數運算，部署了一個誤差檢查函數。

6.安全整數和 Number.isSafeInteger()

JavaScript 能夠準确表示的整數範圍在-253到253之間（不含兩個端點），超過這個範圍，無法精确表示這個值。

Math.pow(2, 53) // 9007199254740992

9007199254740992  // 9007199254740992
9007199254740993  // 9007199254740992

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

上面代碼中，超出 2 的 53 次方之後，一個數就不精确了。

ES6 引入了Number.MAX_SAFE_INTEGER和Number.MIN_SAFE_INTEGER這兩個常量，用來表示這個範圍的上下限。

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

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

上面代碼中，可以看到 JavaScript 能夠精确表示的極限。

Number.isSafeInteger()則是用來判斷一個整數是否落在這個範圍之内。

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

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

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

這個函數的實作很簡單，就是跟安全整數的兩個邊界值比較一下。

Number.isSafeInteger = function (n) {
  return (typeof n === 'number' &&
    Math.round(n) === n &&
    Number.MIN_SAFE_INTEGER <= n &&
    n <= Number.MAX_SAFE_INTEGER);
}

實際使用這個函數時，需要注意。驗證運算結果是否落在安全整數的範圍内，不要隻驗證運算結果，而要同時驗證參與運算的每個值。

Number.isSafeInteger(9007199254740993)
// false
Number.isSafeInteger(990)
// true
Number.isSafeInteger(9007199254740993 - 990)
// true
9007199254740993 - 990
// 傳回結果 9007199254740002
// 正确答案應該是 9007199254740003

上面代碼中，9007199254740993不是一個安全整數，但是Number.isSafeInteger會傳回結果，顯示計算結果是安全的。這是因為，這個數超出了精度範圍，導緻在計算機内部，以9007199254740992的形式儲存。

9007199254740993 === 9007199254740992
// true

是以，如果隻驗證運算結果是否為安全整數，很可能得到錯誤結果。下面的函數可以同時驗證兩個運算數和運算結果。

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

trusty(9007199254740993, 990, 9007199254740993 - 990)
// RangeError: Operation cannot be trusted!

trusty(1, 2, 3)
// 3

7.Math 對象的擴充

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.trunc = Math.trunc || function(x) {
  return x < 0 ? Math.ceil(x) : Math.floor(x);
};

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()

Math.clz32()方法将參數轉為 32 位無符号整數的形式，然後這個 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 representation 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.fround()

Math.fround方法傳回一個數的32位單精度浮點數形式。

ES6 數值的擴充1.二進制和八進制表示法2.Number.isFinite(), Number.isNaN()3.Number.parseInt(), Number.parseFloat()4.Number.isInteger()5.Number.EPSILON6.安全整數和 Number.isSafeInteger()7.Math 對象的擴充8.指數運算符

Math.fround方法的主要作用，是将64位雙精度浮點數轉為32位單精度浮點數。如果小數的精度超過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，此方法傳回原值。對于其它類型的非數值，Math.fround 方法會先将其轉為數值，再傳回單精度浮點數。

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

對于沒有部署這個方法的環境，可以用下面的代碼模拟。

Math.fround = Math.fround || function (x) {
  return new Float32Array([x])[0];
};

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(-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.log1p = Math.log1p || function(x) {
  return Math.log(1 + x);
};

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）

8.指數運算符

ES2016 新增了一個指數運算符（**）。

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

這個運算符的一個特點是右結合，而不是常見的左結合。多個指數運算符連用時，是從最右邊開始計算的。

// 相當于 2 ** (3 ** 2)
2 ** 3 ** 2
// 512

上面代碼中，首先計算的是第二個指數運算符，而不是第一個。

指數運算符可以與等号結合，形成一個新的指派運算符（**=）。

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

上面代碼中，兩個運算結果的最後一位有效數字是有差異的。

ES6 數值的擴充1.二進制和八進制表示法2.Number.isFinite(), Number.isNaN()3.Number.parseInt(), Number.parseFloat()4.Number.isInteger()5.Number.EPSILON6.安全整數和 Number.isSafeInteger()7.Math 對象的擴充8.指數運算符

1.二進制和八進制表示法

2.Number.isFinite(), Number.isNaN()

3.Number.parseInt(), Number.parseFloat()

4.Number.isInteger()

5.Number.EPSILON

6.安全整數和 Number.isSafeInteger()

7.Math 對象的擴充

Math.trunc()

Math.sign()

Math.cbrt()

Math.clz32()

Math.fround()

Math.hypot()

對數方法

1).Math.expm1()

2).Math.log1p()

3).Math.log10()

4).Math.log2()

雙曲函數方法

8.指數運算符

繼續閱讀

你真的了解Class繼承嗎？(es6)ES6總結系列之 Class的繼承篇

promise對象筆記

ES(五) Promise對象、anync函數1.Promise對象2.async函數

Promise對象的用法與執行個體

ES6篇（15）--Promise 對象

ES6--Promise對象

ES6中函數的擴充（函數參數預設值）

ES6參數預設值與rest參數

ES6(4) 字元串擴充

ES6 函數的擴充 rest 參數rest函數

4.ES6-rest參數

異步機制及作用域知識點！

數組方法filter-map-some-reduce底層封裝

ES6入門：數組的擴充運算符

函數節流和防抖（二）—— 節流函數

實作電腦功能前端:如何做一個電腦，實作運算功能，具體如下：