ES6的數值

數值的表示

二進位表示法新寫法: 前綴 0b 或 0B 。

console.log(0b11 === 3); // true
console.log(0B11 === 3); // true

八進位表示法新寫法: 前綴 0o 或 0O 。

console.log(0o11 === 9); // true
console.log(0O11 === 9); // true

常量

Number.EPSILON

Number.EPSILON 屬性表示 1 與大於 1 的最小浮點數之間的差。

它的值接近於 2.2204460492503130808472633361816E-16，或者 2-52。

測試數值是否在誤差範圍內:

0.1 + 0.2 === 0.3; // false
// 在誤差範圍內即視為相等
equal = (Math.abs(0.1 - 0.3 + 0.2) < Number.EPSILON); // true

屬性特性

writable：false
enumerable：false
configurable：false

最大/最小安全整數

安全整數

安全整數表示在 JavaScript 中能夠精確表示的整數，安全整數的範圍在 2 的 -53 次方到 2 的 53 次方之間（不包括兩個端點），超過這個範圍的整數無法精確表示。

最大安全整數

安全整數範圍的上限，即 2 的 53 次方減 1 。

Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2; // true

Number.MAX_SAFE_INTEGER === Number.MAX_SAFE_INTEGER + 1; // false

Number.MAX_SAFE_INTEGER - 1 === Number.MAX_SAFE_INTEGER - 2; // false

最小安全整數

安全整數範圍的下限，即 2 的 53 次方減 1 的負數。

Number.MIN_SAFE_INTEGER + 1 === Number.MIN_SAFE_INTEGER + 2; // false

Number.MIN_SAFE_INTEGER === Number.MIN_SAFE_INTEGER - 1; // false

Number.MIN_SAFE_INTEGER - 1 === Number.MIN_SAFE_INTEGER - 2; //false

屬性特性

writable：false
enumerable：false
configurable：false

方法

Number 對象新方法

Number.isFinite()

用於檢查一個數值是否為有限的（ finite ），即不是 Infinity

console.log( Number.isFinite(1)); // true

console.log( Number.isFinite(0.1)); // true

// NaN 不是有限的

console.log( Number.isFinite(NaN)); // false

console.log( Number.isFinite(Infinity)); // false

console.log( Number.isFinite(-Infinity)); // false

// Number.isFinate 沒有隱式的 Number() 類型轉換，所有非數值都返回 false

console.log( Number.isFinite("foo")); // false

console.log( Number.isFinite("15")); // false

console.log( Number.isFinite(true)); // false

Number.isNaN()

用於檢查一個值是否為 NaN 。

console.log(Number.isNaN(NaN)); // true

console.log(Number.isNaN("true"/0)); // true

// 在全局的 isNaN() 中，以下皆返回 true，因為在判斷前會將非數值向數值轉換

// 而 Number.isNaN() 不存在隱式的 Number() 類型轉換，非 NaN 全部返回 false

Number.isNaN("NaN"); // false

Number.isNaN(undefined); // false

Number.isNaN({}); // false

Number.isNaN("true"); // false

從全局移植到 Number 對象的方法

逐步減少全局方法，用於全局變數的模塊化。

方法的行為沒有發生改變。

Number.parseInt()

用於將給定字元串轉化為指定進位的整數。

// 不指定進位時默認為 10 進位

Number.parseInt("12.34"); // 12

Number.parseInt(12.34); // 12

// 指定進位

Number.parseInt("0011",2); // 3

// 與全局的 parseInt() 函數是同一個函數

Number.parseInt === parseInt; // true

Number.parseFloat()

用於把一個字元串解析成浮點數。

Number.parseFloat("123.45") // 123.45

Number.parseFloat("123.45abc") // 123.45

// 無法被解析成浮點數，則返回 NaN

Number.parseFloat("abc") // NaN

// 與全局的 parseFloat() 方法是同一個方法

Number.parseFloat === parseFloat // true

Number.isInteger()

用於判斷給定的參數是否為整數。

Number.isInteger(value)

Number.isInteger(0); // true

// JavaScript 內部，整數和浮點數採用的是同樣的儲存方法,因此 1 與 1.0 被視為相同的值

Number.isInteger(1); // true

Number.isInteger(1.0); // true

Number.isInteger(1.1); // false

Number.isInteger(Math.PI); // false

// NaN 和正負 Infinity 不是整數

Number.isInteger(NaN); // false

Number.isInteger(Infinity); // false

Number.isInteger(-Infinity); // false

Number.isInteger("10"); // false

Number.isInteger(true); // false

Number.isInteger(false); // false

Number.isInteger([1]); // false

// 數值的精度超過 53 個二進位位時，由於第 54 位及後面的位被丟棄，會產生誤判

Number.isInteger(1.0000000000000001) // true

// 一個數值的絕對值小於 Number.MIN_VALUE（5E-324），即小於 JavaScript 能夠分辨

// 的最小值，會被自動轉為 0，也會產生誤判

Number.isInteger(5E-324); // false

Number.isInteger(5E-325); // true

Number.isSafeInteger()

用於判斷數值是否在安全範圍內。

Number.isSafeInteger(Number.MIN_SAFE_INTEGER - 1); // false

Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1); // false

Math 對象的擴展

ES6 在 Math 對象上新增了 17 個數學相關的靜態方法，這些方法只能在 Math 中調用。

普通計算

Math.cbrt

用於計算一個數的立方根。

Math.cbrt(1); // 1

Math.cbrt(0); // 0

Math.cbrt(-1); // -1

// 會對非數值進行轉換

Math.cbrt("1"); // 1

// 非數值且無法轉換為數值時返回 NaN

Math.cbrt("hhh"); // NaN

Math.imul

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

// 大多數情況下，結果與 a * b 相同

Math.imul(1, 2); // 2

// 用於正確返回大數乘法結果中的低位數值

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

Math.hypot

用於計算所有參數的平方和的平方根。

Math.hypot(3, 4); // 5

// 非數值會先被轉換為數值後進行計算

Math.hypot(1, 2, "3"); // 3.741657386773941

Math.hypot(true); // 1

Math.hypot(false); // 0

// 空值會被轉換為 0

Math.hypot(); // 0

Math.hypot([]); // 0

// 參數為 Infinity 或 -Infinity 返回 Infinity

Math.hypot(Infinity); // Infinity

Math.hypot(-Infinity); // Infinity

// 參數中存在無法轉換為數值的參數時返回 NaN

Math.hypot(NaN); // NaN

Math.hypot(3, 4, "foo"); // NaN

Math.hypot({}); // NaN

Math.clz32

用於返回數字的32 位無符號整數形式的前導0的個數。

Math.clz32(0); // 32

Math.clz32(1); // 31

Math.clz32(0b01000000000100000000000000000000); // 1

// 當參數為小數時，只考慮整數部分

Math.clz32(0.5); // 32

// 對於空值或非數值，會轉化為數值再進行計算

Math.clz32("1"); // 31

Math.clz32(); // 32

Math.clz32([]); // 32

Math.clz32({}); // 32

Math.clz32(NaN); // 32

Math.clz32(Infinity); // 32

Math.clz32(-Infinity); // 32

Math.clz32(undefined); // 32

Math.clz32("hhh"); // 32

數字處理

Math.trunc

用於返回數字的整數部分。

Math.trunc(12.3); // 12

Math.trunc(12); // 12

// 整數部分為 0 時也會判斷符號

Math.trunc(-0.5); // -0

Math.trunc(0.5); // 0

// Math.trunc 會將非數值轉為數值再進行處理

Math.trunc("12.3"); // 12

// 空值或無法轉化為數值時時返回 NaN

Math.trunc(); // NaN

Math.trunc(NaN); // NaN

Math.trunc("hhh"); // NaN

Math.trunc("123.2hhh"); // NaN

Math.fround

用於獲取數字的32位單精度浮點數形式。

// 對於 2 的 24 次方取負至 2 的 24 次方之間的整數（不含兩個端點），返回結果與參數本身一致

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

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

// 用於將 64 位雙精度浮點數轉為 32 位單精度浮點數

Math.fround(1.234) // 1.125

// 當小數的精度超過 24 個二進位位，會丟失精度

Math.fround(0.3); // 0.30000001192092896

// 參數為 NaN 或 Infinity 時返回本身

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

判斷數字的符號（正、負、0）。

Math.sign(1); // 1

Math.sign(-1); // -1

// 參數為 0 時，不同符號的返回不同

Math.sign(0); // 0

Math.sign(-0); // -0

// 判斷前會對非數值進行轉換

Math.sign("1"); // 1

Math.sign("-1"); // -1

// 參數為非數值（無法轉換為數值）時返回 NaN

Math.sign(NaN); // NaN

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

對數方法

Math.expm1()

用於計算 e 的 x 次方減 1 的結果，即 Math.exp(x) - 1 。

Math.expm1(1); // 1.718281828459045

Math.expm1(0); // 0

Math.expm1(-1); // -0.6321205588285577

// 會對非數值進行轉換

Math.expm1("0"); //0

// 參數不為數值且無法轉換為數值時返回 NaN

Math.expm1(NaN); // NaN

Math.log1p(x)

用於計算1 + x 的自然對數，即 Math.log(1 + x) 。

Math.log1p(1); // 0.6931471805599453

Math.log1p(0); // 0

Math.log1p(-1); // -Infinity

// 參數小於 -1 時返回 NaN

Math.log1p(-2); // NaN

Math.log10(x)

用於計算以 10 為底的 x 的對數。

Math.log10(1); // 0

// 計算前對非數值進行轉換

Math.log10("1"); // 0

// 參數為0時返回 -Infinity

Math.log10(0); // -Infinity

// 參數小於0或參數不為數值（且無法轉換為數值）時返回 NaN

Math.log10(-1); // NaN

Math.log2()

用於計算 2 為底的 x 的對數。

Math.log2(1); // 0

// 計算前對非數值進行轉換

Math.log2("1"); // 0

// 參數為0時返回 -Infinity

Math.log2(0); // -Infinity

// 參數小於0或參數不為數值（且無法轉換為數值）時返回 NaN

Math.log2(-1); // NaN

雙曲函數方法

• Math.sinh(x): 用於計算雙曲正弦。
• Math.cosh(x): 用於計算雙曲餘弦。
• Math.tanh(x): 用於計算雙曲正切。
• Math.asinh(x): 用於計算反雙曲正弦。
• Math.acosh(x): 用於計算反雙曲餘弦。
• Math.atanh(x): 用於計算反雙曲正切。

指數運算符

1 ** 2; // 1

// 右結合，從右至左計算

2 ** 2 ** 3; // 256

// **=

let exam = 2;

exam ** = 2; // 4

喜歡這篇文章嗎？立刻分享出去讓更多人知道吧！