ES6数值的扩展

一、 二进制和八进制表示法

• ES6 提供了二进制和八进制数值的新的写法，分别用前缀0b（或0B）和0o（或0O）表示。

0b111110111 === 503 // true
0o767 === 503 // true

• 如果要把以0b或0o为前缀的字符串数值转为十进制，使用Number()方法。

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

二、Number.isFinite(),Number.isNAN()

• Number.isFinite()用来检查一个数值是否为有限的（finite），即不是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

• Number.isNaN()用来检查一个值是否为NaN。如果参数类型不是NaN，返回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

三、Number.parseInt(),Number.parseFloat()

Number.parseInt、Number.parseFloat方法与parseInt、parseFloat方法一模一样，只是为了减少用全局方法，才让语言模块化。

        alert( parseInt('12.34') );		//12
        alert( parseFloat('23.232#') );		//23.232

四、Number.isInteger()

用于判断一个数字是不是整数。

        alert( Number.isInteger(25) );		//true
        //小数返回false
        alert( Number.isInteger(25.3) );	//false
        //25.0 === 25
        alert( Number.isInteger(25.0) );	//true
        //非数字返回false
        alert( Number.isInteger(null) );	//false

• JS数值存储为64位双精度格式，数值精度最多可以达到 53 个二进制位（1 个隐藏位与 52 个有效位）,所以当小数点后太多位可能会有错误出现，如：

Number.isInteger(3.0000000000000002) // true

• 如果一个数值的绝对值小于 5E-324，即小于js能够分辨的最小值，会被自动转为 0,此时也会误判。

Number.isInteger(5E-324) // false
Number.isInteger(5E-325) // true，值为0，是整数

五、Number.EPSILON

Number.EPSILON：表示 1 与大于 1 的最小浮点数之间的差。
引入一个这么小的量的目的，在于为浮点数计算，设置一个误差范围。我们知道浮点数计算是不精确的。

0.1 + 0.2
// 0.30000000000000004

0.1 + 0.2 - 0.3
// 5.551115123125783e-17

5.551115123125783e-17.toFixed(20)
// '0.00000000000000005551'
//因此0.1+0.2不绝对等于0.3
0.1 + 0.2 === 0.3; // false

Number.EPSILON可以用来设置“能够接受的误差范围”。如果两个浮点数的差小于这个值（Number.EPSILON * Math.pow(2, 2)），我们就认为这两个浮点数相等。

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

六、安全整数和Number.isSafeInteger()

• js能够准确表达的整数范围是-2^53~ 2 ^53之间（不包含端点），超过了这个范围就没有办法精准表示这个值。

//超出 2 的 53 次方之后，一个数就不精确了。
Math.pow(2, 53) === Math.pow(2, 53) + 1
// true

• 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.MAX_SAFE_INTEGER和Number.MIN_SAFE_INTEGER用来精准的表示上下线。

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

• 使用Number.isSafeInteger()函数时，如果里面的参数是表达式，则最好判断表达式内的每个值是否都是安全数。由于表达式的原因，如果式子内的结果不为安全数，但存储数据时已将其转化为安全数存储，此时再去调用该函数会返回true。

Number.isSafeInteger(9007199254740993)
// false
Number.isSafeInteger(990)
// true
Number.isSafeInteger(9007199254740993 - 990)
// true
9007199254740993 - 990
// 返回结果 9007199254740002
// 正确答案应该是 9007199254740003

七、Math对象的扩展

1、Math.trunc()

用法：用于去除一个数的小数部分。
（1）对于数字，直接保留整数部分

        alert( Math.trunc(1.23) );
        alert( Math.trunc(-1.23) );
        alert( Math.trunc(0.23) );
        alert( Math.trunc(-0.23) );

（2）对于非数字，直接转化成数值，再保留整数位

        alert( Math.trunc("123.22") );
        alert( Math.trunc(true) );
        alert( Math.trunc(null) );

（3）对于空值和无法转换的值，会返回NaN

        alert( Math.trunc(NaN) );
        alert( Math.trunc() );
        alert( Math.trunc(undefined) );
        alert( Math.trunc("vygv") );

2、Math.sign()

用法：判断一个数到底是正数、负数、还是零。对于非数值，会先将其转换为数值。

参数为正数，返回+1；
参数为负数，返回-1；
参数为 0，返回0；
参数为-0，返回-0;
其他值，返回NaN。

（1）对于数值类型：

        alert( Math.sign(5) );		//1
        alert( Math.sign(-5) );		//-1
        alert( Math.sign(0) );		//0
        alert( Math.sign(-0) );		//0,没有返回-0
        alert( Math.sign(NaN) );	//NaN

（2）对于非数值类型：

        alert( Math.sign('') );		//0
        alert( Math.sign() );		//NaN
        alert( Math.sign(true) );	//1
        alert( Math.sign(null) );	//0
        alert( Math.sign('3') );	//1
        alert( Math.sign("fnw") );	//NaN
        alert( Math.sign(undefined) );	//NaN

3、Math.cbrt()

用法：用于计算一个数值的立方根。
（1）对于数值类型：

        alert( Math.cbrt(1) );		//1
        alert( Math.cbrt(-1) );		//-1
        alert( Math.cbrt(0) );		//0
        alert( Math.cbrt(2) );		//1.2599210498948732

（2）对于非数值类型，先转化为数值再计算：

        alert( Math.cbrt() );			//NaN
        alert( Math.cbrt("") );			//0
        alert( Math.cbrt('27') );		//3
        alert( Math.cbrt("fsfs") );		//NaN
        alert( Math.cbrt(true) );		//1
        alert( Math.cbrt(null) );		//0
        alert( Math.cbrt(NaN) );		//NaN
        alert( Math.cbrt(undefined) );	//NaN

4、Math.clz32()

用法：将参数转为 32 位无符号整数的形式（二进制形式下），然后返回这个 32 位值里面有多少个前导 0。

Math.clz32(0) // 32,0的二进制形式全为0，所以有32个0
Math.clz32(1) // 31，1的二进制形式只有一个1，所以有31个0
Math.clz32(1000) // 22
Math.clz32(0b01000000000000000000000000000000) // 1
Math.clz32(0b00100000000000000000000000000000) // 2

• 左移运算符与该方法直接相关

Math.clz32(0) // 32
Math.clz32(1) // 31
Math.clz32(1 << 1) // 30
Math.clz32(1 << 2) // 29
Math.clz32(1 << 29) // 2

• 对于小数，该方法只考虑整数部分

alert( Math.clz32(1.2) );		//31

• 对于非数值，会将其转换为数值，在调用该方法

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

5、Math.imul(a,b)

用法：返回两个数以 32 位带符号整数形式相乘的结果，返回的也是一个 32 位的带符号整数。

• 正常情况下，该方法返回的就是a*b，但是对于那些位数较大的数字，直接相乘可能会使结果不精确。

Math.imul(2, 4)   // 8
Math.imul(-1, 8)  // -8
//直接相乘不精确
(0x7fffffff * 0x7fffffff)|0 // 0
//调用该方法后返回正确结果
Math.imul(0x7fffffff, 0x7fffffff) // 1

6、Math.fround()

用法：返回一个数的32位单精度浮点数形式。

• 所以对于 -2 ^24 至 2 ^24 之间的整数（不含两个端点），返回结果与参数本身一致。

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

• 若超出了这个精度范围，就开始丢失精度。

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

• 对于NaN 和 Infinity，此方法返回原值。对于其它类型的非数值，Math.fround 方法会先将其转为数值，再返回单精度浮点数。

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

6、Math.hypot()

用法：返回所有参数的平方和的平方根。

• Math.hypot方法会将其转为数值。只要有一个参数无法转为数值，就会返回 NaN。

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

• 对数方法

1、Math.expm1()

用法：Math.expm1(x)返回 ex - 1，即Math.exp(x) - 1。

Math.expm1(-1) // -0.6321205588285577
Math.expm1(0)  // 0
Math.expm1(1)  // 1.718281828459045

2、Math.log1p()

用法：返回1 + x的自然对数，即Math.log(1 + x)。如果x小于-1，返回NaN。

alert(Math.log1p(1));		//0.6931471805599453

3、Math.log10()

用法：返回以 10 为底的x的对数。如果x小于 0，则返回 NaN。

Math.log10(1)      // 0
Math.log10(0)      // -Infinity
Math.log10(10)		//1

3、Math.log2()

用法：返回以 2 为底的x的对数。如果x小于 0，则返回 NaN。

Math.log2(2)       // 1
Math.log2(1)       // 0
Math.log2(0)       // -Infinity

• 双曲函数方法

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）

八、指数运算符

ES2016新增了指数运算符：**

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

该运算符从右向左结合。

alert(2**1**4);			//2

(**=): 当**与=结合在一起时

let a = 1.5;
a **= 2;
// 等同于 a = a * a;

let b = 4;
b **= 3;
// 等同于 b = b * b * b;

九、BigInt数据类型

ES2020 引入了一种新的数据类型 BigInt（大整数）。BigInt 只用来表示整数，没有位数的限制，任何位数的整数都可以精确表示。

• 大整数必须加 n 在数字后

1234 // 普通整数
1234n // BigInt

// BigInt 的运算
alert(1n+3n);	//4

• 大数值类型也可以用各种进制表示，但是都必须加上后缀n

0b1101n // 二进制
0o777n // 八进制
0xFFn // 十六进制

• 大整数和普通整数是两种值，所以它们并不相等

alert(11 === 11n);	 // false

• 大整数类型可以在数字前加 - 号，但是不能加 + 号

        alert(-32n);	//-32
        alert(+23n);	//报错

BigInt对象

js原生提供BigInt对象，用于把其他数据类型转化成BigInt类型。

        alert(BigInt(123));
        alert(BigInt('1234'));
        alert(BigInt(true));

BigInt函数必须有参数，且参数必须能够转化为数值，否则会报错。

BigInt(undefined) //TypeError
BigInt(null) 	  // TypeError
BigInt('123n')	  // SyntaxError
BigInt('abc') 	  // SyntaxError

//如果是小数也会报错
BigInt(1.5) // RangeError
BigInt('1.5') // SyntaxError

转换规则

可以使用Boolean()、Number()和String()这三个方法，将 BigInt 转换成对应类型。

Boolean(0n) // false
Boolean(1n) // true
Number(1n)  // 1

//转为字符串时n会消失
String(1n)  // "1"

• 取反运算符（!）也可以将 BigInt 转为布尔值。

!0n // true
!1n // false

数学运算

BigInt 类型的+、-、*和**这四个二元运算符，与 Number 类型的行为一致。除法运算会直接舍去小数部分，返回一个整数。

9n / 5n			// 1n

• BigInt 不能与普通数值进行混合运算。

1n + 1.3 // 报错，无论返回的是 BigInt 或 Number，都会导致丢失精度信息

其他运算

• BigInt 对应的布尔值，与 Number 类型一致，即0n会转为false，其他值转为true

if (0n) {
  console.log(true);
} else {
  console.log(false);
}

• 比较运算符（比如>）和相等运算符（==）允许 BigInt 与其他类型的值混合计算。

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

• BigInt 与字符串混合运算时，会先转为字符串，再进行运算。

'' + 123n // "123"