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
1
2

• 如果要将 0b 和 0o 前缀的字符串数值转为十进制，要使用 Number 方法。

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

1.2. 数值判断方法:

1.2.1. Number.isFinite() 检查一个值是否为有限的数值。

console.log(Number.isFinite(15)); // true
console.log(Number.isFinite(Infinity)); // 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
1
2
3
4
5
6
7
8
9
10
11

1.2.2. Number.isNaN() 更准确地检测NaN值。

console.log(Number.isNaN(NaN)); // true
console.log(Number.isNaN("Hello")); // false

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
1
2
3
4
5
6
7
8
9
10

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
2
3
4
5
6
7
8
9

1.3. 数值转换方法:

• Number.parseInt() 和 Number.parseFloat() 作为全局函数的严格版本，直接绑定在 Number 对象上。

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

这样做的目的，是逐步减少全局性方法，使得语言逐步模块化。

Number.parseInt === parseInt // true
Number.parseFloat === parseFloat // true
1
2

1.4. 整数检查与精度:

1.4.1. Number.isInteger() 判断一个值是否为整数。

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

需要注意的是，在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
2
3
4
5

1.4.2. Number.EPSILON 提供了一个极小的常量，用于比较浮点数时的误差容限。

根据规格，它表示1与大于1的最小浮点数之间的差。

let num = 0.1 + 0.2;
console.log(Math.abs(num - 0.3) < Number.EPSILON); // true，判断浮点运算的误差
1
2

Number.EPSILON 实际上是 JavaScript 能够表示的最小精度。误差如果小于这个值，就可以认为已经没有意义了，即不存在误差了。

引入一个这么小的量的目的，在于为浮点数计算，设置一个误差范围。我们知道浮点数计算是不精确的。

Number.EPSILON 可以用来设置“能够接受的误差范围”。

比如，误差范围设为2的-50次方（即 Number.EPSILON * Math.pow(2, 2) ），即如果两个浮点数的差小于这个值，我们就认为这两个浮点数相等。

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

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  
1
2
3
4

上面代码中，超出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
1
2
3
4
5
6
7
8

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
2
3
4
5
6
7
8
9
10
11
12
13

1.5. 数值分隔符:

• 数值字面量中可以使用下划线 _ 作为视觉上的千位分隔符，提高可读性。

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

1.6. Math对象的扩展:

ES6对Math对象进行了扩展，增加了一系列新的方法来提供更强大的数学运算功能。以下是一些主要的扩展方法及其使用示例：

1.6.1. Math.trunc() 移除一个数的小数部分，返回整数部分。

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

对于非数值， Math.trunc 内部使用 Number 方法将其先转为数值。

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

对于空值和无法截取整数的值，返回 NaN 。

Math.trunc(NaN); // NaN
Math.trunc('foo'); // NaN
Math.trunc(); // NaN
Math.trunc(undefined) // NaN
1
2
3
4

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
2
3
4
5

1.6.3. Math.cbrt():

计算一个数的立方根。

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

1.6.4. Math.hypot():

返回所有参数的平方和的平方根，常用于计算直角三角形的斜边长度。

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

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
2
3
4

1.6.6. Math.clz32():

返回一个数的32位无符号整数形式的前导零的个数。

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

这些方法丰富了JavaScript的数学运算能力，使得处理数学问题更加高效和便捷。