ECMA Script 6_數值的擴展

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

前綴 0b（或0B） 表示 二進制

前綴 0o（或 0O ）表示 八進制

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

• 若是要將 0b 和 0o 前綴的字符串數值 轉爲十進制，要使用 Number() 方法
  

2. Number.isFinite()

檢查一個數值是否爲有限的（finite），即 不是 Infinity 返回 true

只對數值有效

若是參數類型不是數值，Number.isFinite一概返回false

• 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

3. 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

4. Number.parseInt() 和 Number.parseFloat()

將 全局方法 移植到對象 上面，行爲徹底保持不變

是爲了 逐步減小全局性方法，使得語言逐步模塊化

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

5. Number.isInteger()

判斷一個數值是否爲整數

• 整數 和 浮點數 採用的是一樣的儲存方法，因此 25 和 25.0 被視爲同一個值

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

• JavaScript 採用 IEEE 754 標準，數值存儲爲64位雙精度格式，數值精度最多能夠達到 53 個二進制位（1 個隱藏位與 52 個有效位）。
• 若是數值的精度超過這個限度，第54位及後面的位就會被丟棄，這種狀況下，Number.isInteger可能會誤判。

• Number.isInteger(3.0000000000000002);    // true

因此，若是對數據精度的要求較高，不建議使用 Number.isInteger() 判斷一個數值是否爲整數

6. Number.EPSILON

ES6 在 Number 對象上面，新增 一個極小的常量 Number.EPSILON ，即 JavaScript 可以表示的最小精度。

偏差若是小於這個值，就能夠認爲已經沒有意義了，即不存在偏差了

根據規格，它表示 1 與大於 1 的最小浮點數之間的差

• 對於 64 位浮點數來講，大於 1 的最小浮點數至關於二進制的1.00..001，小數點後面有連續 51 個零。
• 這個值減去 1 以後，就等於 2 的 -52 次方
• 用來設置 「可以接受的偏差範圍」

好比，偏差範圍設爲 2 的-50 次方（即Number.EPSILON * Math.pow(2, 2)），

即若是兩個浮點數的差小於這個值，咱們就認爲這兩個浮點數相等

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

• 一個能夠接受的最小偏差範圍

• // 偏差範圍設爲 2 的 -50 次方
  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

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

JavaScript 可以準確表示的整數範圍在-2^53到2^53之間（不含兩個端點），超過這個範圍，沒法精確表示這個值

• Number.isSafeInteger()

判斷一個整數是否落在 [-2^53, 2^53] 範圍以內

• 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

• 驗證 整個運算 是否可靠

• 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

Math 對象的擴展

Math.trunc()

去除一個數的小數部分，返回整數部分

對於非數值，Math.trunc() 內部使用 Number() 將其先轉爲數值

• 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('123.456');    // 123
  Math.trunc(true);    //1
  Math.trunc(false);    // 0
  Math.trunc(null);    // 0

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

Math.cbrt

用於計算一個數的立方

於非數值，Math.cbrt() 方法內部也是先使用 Number() 將其轉爲數值

• Math.cbrt('8');    // 2

Math.clz32() 

返回一個數的 32 位無符號整數形式有多少個前導 0

JavaScript 中，整數使用 32 位二進制形式表示

」count leading zero bits in 32-bit binary representation of a number「（計算一個數的 32 位二進制形式的前導 0 的個數）的縮寫

• 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

• 對於小數，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()

返回兩個數以 32 位帶符號整數形式相乘的結果，

返回的也是一個 32 位的帶符號整數

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

Math.fround()

返回一個數的 32 位單精度浮點數形式

主要做用，是將64位雙精度浮點數轉爲32位單精度浮點數。

若是小數的精度超過 24 個二進制位，返回值就會不一樣於原值，

不然返回值不變（即與64位雙精度值一致）

• 對於32位單精度格式來講，數值精度是24個二進制位（1 位隱藏位與 23 位有效位），因此對於 -224 至 224 之間的整數（不含兩個端點），返回結果與參數自己一致

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

• 若是參數的絕對值大於 2的24次方，返回的結果便開始丟失精度

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

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

新增的 4 個 對數方法

Math.expm1(x)

返回 e 的 x 次方 - 1，即 Math.exp(x) - 1

Math.log1p()

返回 1 + x 的天然對數，即 Math.log(1 + x)

若是 x 小於-1，返回 NaN

Math.log10()

返回以 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.log2()

333

• 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.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 新增了一個指數運算符（**）

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

• 右結合，而不是常見的左結合。

多個指數運算符連用時，是從最右邊開始計算的

• 2 ** 3 ** 2    // 至關於 2 ** (3 ** 2)
  // 512

• 指數運算符能夠與等號結合，造成一個新的賦值運算符（**=）
  

• let a = 1.5;
  a **= 2;    // 等同於 a = a * a;    2.25
  
  let b = 4;
  b **= 3;    // 等同於 b = b * b * b;   64

• 注意： V8 引擎的 指數運算符 與 Math.pow() 的實現不相同，對於特別大的運算結果，二者會有細微的差別

• Math.pow(99, 99)    // 3.697296376497263e+197
  
  99 ** 99    // 3.697296376497268e+197
  
  // 上面代碼中，兩個運算結果的最後一位有效數字是有差別的。