ES6-数值扩展

1、二进制数值用 0b 或者 0B作为前缀，八进制用 0o 或者 0O表示

2、数值分隔符可以使用 _ 进行分隔,增加数值的可读性

100_000_000 === 10**8 // true

0.000_001 === 0.000001 // true
0.00000_1 === 0.000001 // true
1e10_000 // 科学计数法有分隔符的写法
0b1_001 //二进制
0O1_001 //八进制
0X1_001 //十六进制

// 1、分隔符不能放在数值前后，会报错。例如：_100000   100000_

// 2、分隔符不能放在小数点前后，会报错。例如：10._111   10_.111

// 3、两个及以上的分隔符不能使用，会报错。例如：10__0000  0.1____22222 

// 4、科学计数法里 e或者E前后不能有分隔符，会报错。例如：10e_11   10_E11  

// 5、分隔符不能放在进制修饰符前后及中间，会报错。例如：_0b1001   0_O1001   0X_1001

3、Number.isFinite() 和 Number.isNaN()

// 判断数值是不是有限的
Number.isFinite(12) // true
Number.isFinite(0.8) // true
Number.isFinite(true) // false
Number.isFinite(NaN) // false
Number.isFinite('fafdaf') // false
Number.isFinite('154324') // false  
Number.isFinite(-Infinity) // false
Number.isFinite(-Infinity) // false

// 判断是不是 NaN
Number.isNaN(NaN) // true
Number.isNaN(9/NaN) // true
Number.isNaN(.9/NaN) // true
Number.isNaN(true/NaN) // true
Number.isNaN('43214'/NaN) // true
Number.isNaN('gfdsf'/NaN) // true
Number.isNaN(true / 32) // false
Number.isNaN(11) // false
Number.isNaN(.9) // false
Number.isNaN(true) // false
Number.isNaN('43214') // false
Number.isNaN('gfdsf') // false

// 注意全局方法 isFinite() 和 isNaN() , 都会先调用 Number()方法，再判断是不是有限的,例如
Number.isNaN('gfdsf') // false
isNaN('gfdsf') // true

Number.isFinite('154324') // false 
isFinite('154324') // true

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

// ES6将全局的方法 parseInt() 和 parseFloat() 移植到 Number上，减少全局方法，逐步模块化
Number.parseInt === parseInt // true 
Number.parseFloat === parseFloat // true

Number.parseFloat() // NaN
Number.parseFloat('dsad') // NaN
Number.parseFloat('dasq11111') // NaN
Number.parseFloat(true) // NaN
Number.parseFloat(NaN) // NaN
Number.parseFloat(11) // 11
Number.parseFloat('11') // 11
Number.parseFloat('11.11q2sda') //11.11

Number.parseInt() // NaN
Number.parseInt('dsad') // NaN
Number.parseInt('dasq11111') // NaN
Number.parseInt(true) // NaN
Number.parseInt(NaN) // NaN
Number.parseInt(11) // 11
Number.parseInt(11.111) // 11
Number.parseInt('11') // 11
Number.parseInt('11.1111') // 11
Number.parseInt('11.11q2sda') // 11

5、Number.isInteger(): 判断是否是整数

// javascript 采用 IEEE 754标准，数值存储为64位双精度格式
// 数值精度最多可以达到 53个二进制位（一个隐藏位和52个有效位），如果超过，第54位及之后会被舍弃
Number.isInteger(25) // true
Number.isInteger(25.0) // true
Number.isInteger(25.0000000000000002) // true  ---> 小数点后16个十进制转为二进制，超过53个二进制，导致最后位被舍弃
Number.isInteger(5E-324) // true ---> 5E-324是 MIN-VALUE，小于js能分辨的最小值，会被自动转为 0

Number.isInteger(25.1) // false
Number.isInteger(false) // false
Number.isInteger(NaN) // false
Number.isInteger(null) // false
Number.isInteger(undefined) // false
Number.isInteger('25') // false
Number.isInteger('25.0') // false
Number.isInteger('25.22') // false

6、Number.EPSILON: 最小常量,一般用来设置精度误差范围

// Number.EPSILON 是大于 1 的最小浮点数 1.0000000000000000000000000000000000000000000000000001 - 1 的结果值，也就是 2 的 -52 次方
Number.EPSILON === Math.pow(2, -52) // true

// 因为 JavaScript 运算都是有精度误差，所以可以使用 Number.EPSILON 来设置误差范围
0.1+0.2 === 0.3 // false
0.1+0.2-0.3 < Number.EPSILON // true

7、Number.MAX_SAFE_INTEGER 、Number.MIN_SAFE_INTEGER 及 Number.isSafeInteger(整数值)

Number.MAX_SAFE_INTEGER // 最大安全数，等于 Math.pow(2, 53) - 1
Number.MIN_SAFE_INTEGER // 最小安全数
Number.isSafeInteger(11) // 判断一个整数是不是位于安全数（大于-2^53到小于2^53）之间,javascript只能精确识别安全数，超过了，就不准确了

Number.MAX_SAFE_INTEGER === -Number.MIN_SAFE_INTEGER // true
Number.MAX_SAFE_INTEGER === Math.pow(2, 53) - 1
Number.MIN_SAFE_INTEGER === -9007199254740991
Number.isSafeInteger(false) // false
Number.isSafeInteger(NaN) // false
Number.isSafeInteger(null) // false
Number.isSafeInteger(undefined) // false
Number.isSafeInteger(Infinity) // false
Number.isSafeInteger(-Infinity) // false
Number.isSafeInteger('das') // false
Number.isSafeInteger('312das') // false
Number.isSafeInteger('312') // false
Number.isSafeInteger('312.2222') // false
Number.isSafeInteger(9007199254740992) // false
Number.isSafeInteger(-9007199254740992) // false
Number.isSafeInteger(-9007199254740991) // true
Number.isSafeInteger(9007199254740991) // true
Number.isSafeInteger(11) // true
Number.isSafeInteger(Number.MIN_SAFE_INTEGER) // true
Number.isSafeInteger(Number.MAX_SAFE_INTEGER) // true

8、Math.trunc(): 获取一个数的整数部分

Math.trunc(1.22) // 1
Math.trunc(1.88) // 1
Math.trunc(-1.22) // -1
Math.trunc(-1.88) // -1
Math.trunc('-1.88') // -1
Math.trunc('-1.22') // -1
Math.trunc(true) // 1
Math.trunc(false) // 0
Math.trunc(null) // 0
Math.trunc('') // 0
Math.trunc('dada') // NaN
Math.trunc('11.22dada') // NaN
Math.trunc(undefined) // NaN
Math.trunc(NaN) // NaN
Math.trunc() // NaN

9、Math.sign()：判断一个数是不是正数、负数或者 0

Math.sign(1) // 正数，返回 1
Math.sign('1') // 1

Math.sign(-1) // 负数，返回 -1
Math.sign('-1') // 负数，返回 -1

Math.sign(-0) // -0
Math.sign(0) // 0
Math.sign('') // 0
Math.sign(null) // 0

Math.sign('dsa') // NaN
Math.sign('dsa11') // NaN
Math.sign('11dsa') // NaN
Math.sign(undefined) // NaN
Math.sign(NaN) // NaN
Math.sign() // NaN

10、BigInt: 大整数
JavaScript 的所有数字只能使用64位双精度浮点数格式存储。
所以数值的精度只能到53个二进制位或者是16个十进制位，多了就没有办法精确表示了;
大于2的1024次方的数，JavaScript 也是没有办法表示的，直接给返回 Infinity。
ES2020就引入 BigInt（大整数）来表示，它是没有位数的限制，都可以精确表示

1234 // 普通数值
1234n // 大整数
2n + 3n // 5n
typeof 12n // bigint
-12n
+12n // 报错，与 asm.js 冲突

BigInt(12) // 12n
BigInt('12') // 12n
BigInt(false) // 0n
BigInt(true) // 1n

BigInt(1.5) // RangeError

new BigInt() // TypeError
BigInt(undefined) //TypeError
BigInt(null) // TypeError

BigInt('123n') // SyntaxError
BigInt('abc') // SyntaxError
BigInt('1.5') // SyntaxError


Boolean(1n) // true
Boolean(0n) // false
String(1n) // '1' 
Number(1n) // 1
!0n // true
!1n // false
!3223n // false
1n + 2n // 3n
2n - 1n // 1n
3n * 3n // 9n
9n / 5n // 1n
9n / 4n // 2n
9n / 3n // 3n

0n < 1 // true
0n < true // true
0n == 0 // true
0n == false // true
0n === 0 // false

'' + 123n // "123"  BigInt 与字符串混合运算时，会先转为字符串，再进行运算。
1n+1.2 // 报错  BigInt 不能与普通数值进行混合运算
1n | 0 // 报错 BigInt 不能与普通数值进行混合运算

就记录到这，祝大家开心~