ES6之數值的擴展

1. 數值的擴展
- 1.1. 二進制和八進制字面量表示:
- 1.2. 數值判斷方法:
  - 1.2.1. Number.isFinite() 檢查一個值是否為有限的數值。
  - 1.2.2. Number.isNaN() 更準確地檢測NaN值。
  - 1.2.3. 傳統的全局方法 isFinite() 和 isNaN() 的區別
- 1.3. 數值轉換方法:
- 1.4. 整數檢查與精度:
  - 1.4.1. Number.isInteger() 判斷一個值是否為整數。
  - 1.4.2. Number.EPSILON 提供了一個極小的常量，用于比較浮點數時的誤差容限。
  - 1.4.3. Number.isSafeInteger() 檢查一個值是否為安全的整數（在 -(2^53) 到 2^53 之間）。
- 1.5. 數值分隔符:
- 1.6. Math對象的擴展:
  - 1.6.1. Math.trunc() 移除一個數的小數部分，返回整數部分。
  - 1.6.2. Math.sign():
  - 1.6.3. Math.cbrt():
  - 1.6.4. Math.hypot():
  - 1.6.5. 對數方法:
  - 1.6.6. Math.clz32():

1. 數值的擴展

ECMAScript 6 (ES6) 對數值的擴展引入了一些新的特性和方法，旨在提高數值處理的便利性和精確度。

以下是一些關鍵的擴展點及其示例：

1.1. 二進制和八進制字面量表示:

ES6 引入了新的字面量表示法來直接表示二進制和八進制數。
- 二進制前綴為 0b 或 0B，
- 八進制前綴為 0o 或 0O。

let binary = 0b1010; // 二進制表示10，十進制為10
let octal = 0o12;    // 八進制表示12，十進制為10

如果要將 0b 和 0o 前綴的字符串數值轉為十進制，要使用 Number 方法。

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

1.2. 數值判斷方法:

1.2.1. `Number.isFinite()` 檢查一個值是否為有限的數值。

console.log(Number.isFinite(15)); // true
console.log(Number.isFinite(Infinity)); // falseNumber.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

1.2.2. `Number.isNaN()` 更準確地檢測`NaN`值。

console.log(Number.isNaN(NaN)); // true
console.log(Number.isNaN("Hello")); // falseNumber.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

1.2.3. 傳統的全局方法 isFinite() 和 isNaN() 的區別

傳統方法先調用 Number() 將非數值的值轉為數值，再進行判斷，
而這兩個新方法只對數值有效， Number.isFinite() 對于非數值一律返回 false , Number.isNaN() 只有對于 NaN 才返回 true ，非 NaN 一律返回 false 。

isFinite(25) // true
isFinite("25") // true
Number.isFinite(25) // true
Number.isFinite("25") // false
isNaN(NaN) // true
isNaN("NaN") // true
Number.isNaN(NaN) // true
Number.isNaN("NaN") // false
Number.isNaN(1) // false

1.3. 數值轉換方法:

Number.parseInt() 和 Number.parseFloat() 作為全局函數的嚴格版本，直接綁定在 Number 對象上。

console.log(Number.parseInt("123px")); // 123
console.log(Number.parseFloat("123.45em")); // 123.45

這樣做的目的，是逐步減少全局性方法，使得語言逐步模塊化。

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

1.4. 整數檢查與精度:

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

console.log(Number.isInteger(42)); // true
console.log(Number.isInteger(42.1)); // false

需要注意的是，在JavaScript 內部，整數和浮點數是同樣的儲存方法，所以3和3.0被視為同一個值。

Number.isInteger(25) // true
Number.isInteger(25.0) // true
Number.isInteger(25.1) // false
Number.isInteger("15") // false
Number.isInteger(true) // false

1.4.2. `Number.EPSILON` 提供了一個極小的常量，用于比較浮點數時的誤差容限。

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

let num = 0.1 + 0.2;
console.log(Math.abs(num - 0.3) < Number.EPSILON); // true，判斷浮點運算的誤差

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

引入一個這么小的量的目的，在于為浮點數計算，設置一個誤差范圍。我們知道浮點數計算是不精確的。

Number.EPSILON 可以用來設置“能夠接受的誤差范圍”。

比如，誤差范圍設為2的-50次方（即 Number.EPSILON * Math.pow(2, 2) ），即如果兩個浮點數的差小于這個值，我們就認為這兩個浮點數相等。

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

1.4.3. `Number.isSafeInteger()` 檢查一個值是否為安全的整數（在 -(2^53) 到 2^53 之間）。

超過這個范圍，無法精確表示這個值。

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

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

1.5. 數值分隔符:

數值字面量中可以使用下劃線 _ 作為視覺上的千位分隔符，提高可讀性。

let million = 1_000_000; // 等同于1000000

1.6. Math對象的擴展:

ES6對Math對象進行了擴展，增加了一系列新的方法來提供更強大的數學運算功能。以下是一些主要的擴展方法及其使用示例：

1.6.1. `Math.trunc()` 移除一個數的小數部分，返回整數部分。

console.log(Math.trunc(3.14)); // 3

對于非數值， 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

1.6.2. `Math.sign()`:

用來判斷一個數的符號，返回五種可能的值：1（正數）、0（零）、-1（負數）、-0（負零）、NaN（非數字）。

console.log(Math.sign(23));   // 輸出: 1
console.log(Math.sign(-23));  // 輸出: -1
console.log(Math.sign(0));    // 輸出: 0
console.log(Math.sign(-0));   // 輸出: -0
console.log(Math.sign('a'));  // 輸出: NaN

1.6.3. `Math.cbrt()`:

計算一個數的立方根。

console.log(Math.cbrt(27)); // 輸出: 3

1.6.4. `Math.hypot()`:

返回所有參數的平方和的平方根，常用于計算直角三角形的斜邊長度。

console.log(Math.hypot(3, 4)); // 輸出: 5

1.6.5. 對數方法:

Math.expm1(x) 返回 e^x - 1。
Math.log1p(x) 返回 1 + x 的自然對數。
Math.log10(x) 返回以10為底x的對數。
Math.log2(x) 返回以2為底x的對數。

console.log(Math.expm1(1));  // 輸出:約等于 1.71828
console.log(Math.log1p(1));  // 輸出: 0.6931471805599453
console.log(Math.log10(100)); // 輸出: 2
console.log(Math.log2(8));    // 輸出: 3

1.6.6. `Math.clz32()`:

返回一個數的32位無符號整數形式的前導零的個數。

console.log(Math.clz32(0b00000000000000000000000000001010)); // 輸出: 26

這些方法豐富了JavaScript的數學運算能力，使得處理數學問題更加高效和便捷。