es6之数值的扩展方法

1.二进制、八进制、十六进制的表示方法

二进制：0b(或0B)
八进制：0o(或0O)
十六进制：0x(或0X)

        console.log(0b10===2) //true
        console.log(0o10===8) //true
        console.log(0x10===16) //true

使用Number函数可将其他进制的数值转换为10进制
其他进制的数值进行运算时，会先将其转换成10进制数，再进行运算

        console.log(Number(0b10))   //2
        console.log(Number(0o10))   //8
        console.log(Number(0x10))   //16
        console.log(0b10+0x10)  //18

2.数值分隔符

es6规定，js的数值可以使用下划线（_）作为数值分隔符
这个数值分隔符没有指定间隔的位数

        console.log(10000000===10_0_0_0000)  //true

小数和科学计数法也可以使用数值分隔符

        console.log(0.000_00_1===0.000001)  //true
        console.log(1e10_0_00===1e10000)  //true

注意：
不能放在数值的最前面（leading）或最后面（trailing）。
不能两个或两个以上的分隔符连在一起。
小数点的前后不能有分隔符。
科学计数法里面，表示指数的e或E前后不能有分隔符。

除了十进制，其他进制的数值也可以使用分隔符。

        console.log(0b1010_0001_10_000_101===0b1010000110000101)    //true

注意：分隔符不能紧跟着进制的前缀
数值分隔符只是一种数值便于读写的操作，不影响内部数值的存储和输出。

        let num = 10_000;
        console.log(num.toString()) //10000
//注意：Number()、parseInt()、parseFloat()这三种方法不支持数值分隔符
        console.log(Number('10_000') ) //NaN
        console.log(parseInt('10_000')) //10

3.Number.isFinite(), Number.isNaN()

Number.isFinite()检查数值是否有限
Number.isNaN()检查一个值是否为NaN

与传统方法isFinite()和isNaN()不同的是，传统方法是先调用Number()将非数值的值转化位数值。

        console.log(isFinite('666'))    //true
        console.log(Number.isFinite('666'))     //false
        console.log(isNaN("NaN"))    //true
        console.log(Number.isNaN("NaN"))     //false

4.Number.parseInt(), Number.parseFloat()

与传统方法parseInt()和parseFloat()效果一样，这样做的目的，是逐步减少全局性方法，使得语言逐步模块化。

        // ES5的写法
        console.log(parseInt('3.21')) //3
        console.log(parseFloat('3.45.66'))  //3.45

        // ES6的写法
        console.log(Number.parseInt('3.21'))   //3
        console.log( Number.parseFloat('3.45.66'))  //3.45

5.Number.isInteger()

Number.isInteger()方法用来判断一个数值是否为整数

        console.log(Number.isInteger(6))    //true
        console.log(Number.isInteger(6.26))     //false
        console.log(Number.isInteger(6.00))     //true
//如果参数不是数值，Number.isInteger则会返回false

6.Number.EPSILON

ES6 在Number对象上面，新增一个极小的常量Number.EPSILON
 

        console.log(Number.EPSILON === Math.pow(2, -52))    //true

7.安全整数和 Number.isSafeInteger()

js能够准确表示的整数范围在-2^53到2^53之间（不含两个端点），超过这个范围，无法精确表示这个值。

        console.log(Math.pow(2, 53) === Math.pow(2, 53) + 1)    //true
//Number.isSafeInteger()则是用来判断一个整数是否落在这个范围之内。
        console.log(Number.isSafeInteger(Infinity))   // false
        console.log(Number.isSafeInteger(6))   // true

8.Math 对象的扩展

Math.trunc方法用于去除一个数的小数部分，返回整数部分。
对于非数值，Math.trunc内部使用Number方法将其先转为数值。
对于空值和无法截取整数的值，返回NaN。

        console.log(Math.trunc(66.669)) //66
        console.log(Math.trunc('66.669')) //66
        console.log(Math.trunc()) //NaN

Math.sign() 方法用来判断一个数到底是正数、负数、还是零。对于非数值，会先将其转换为数值。

        console.log(Math.sign('2'))     //1
        console.log(Math.sign('0'))     //0
        console.log(Math.sign('-2'))    //-1
        console.log(Math.sign(''))      //0
        console.log(Math.sign('qqq'))   //NaN

Math.cbrt()方法用于计算一个数的立方根。

        console.log(Math.cbrt('-8'))    //-2
        console.log(Math.cbrt('8'))    //2
        console.log(Math.cbrt('3'))    //1.4422495703074083
        console.log(Math.cbrt('ghh'))    //NaN

Math.hypot()方法返回所有参数的平方和的平方根

        let a = Math.hypot(3,4)
        console.log(a)  //5
        //如果参数不是数值，Math.hypot方法会将其转为数值。只要有一个参数无法转为数值，就会返回 NaN。

9.BigInt数据类型

JavaScript 所有数字都保存成 64 位浮点数，这给数值的表示带来了两大限制。

1.数值的精度只能到 53 个二进制位（相当于 16 个十进制位），大于这个范围的整数,JavaScript 是无法精确表示。

        const a = 9000000000000000000003;
        const b = 9000000000000008;
        console.log(a*b) //8.100000000000008e+37
        //很显然上面的计算结果精度丢失

2.大于或等于2的1024次方的数值，JavaScript 无法表示，会返回Infinity。

        const a = Math.pow(2, 1024);
        console.log(a) //Infinity

BigInt 只用来表示整数，没有位数的限制，任何位数的整数都可以精确表示。

        const a = 9000000000000000000003n;
        const b = 9000000000000008n;
        console.log(a*b) //81000000000000072000027000000000000024n

为了与 Number 类型区别，BigInt 类型的数据可以使用各种进制表示,但必须添加后缀n。

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

BigInt 与普通整数是两种值，它们之间并不相等。

        console.log(1n == 1) //true
        console.log(1n === 1) //false

typeof运算符对于 BigInt 类型的数据返回bigint。  

        console.log(typeof 1) //number
        console.log(typeof 1n) //bigint

只能使用正号（+），不能使用负号（-）

        console.log(-42n) //-42n
        console.log(+42n) //Uncaught TypeError: Cannot convert a BigInt value to a number

BigInt 类型的数据可以表示出2的1024次方

        //Number类型
        let p = 2;
        for (let i = 1; i <= 1025; i++) {
            p *= 2;
        }
        console.log(p); // Infinity
        //BigInt类型
        let p = 2n;
        for (let i = 1; i <= 1025; i++) {
            p *= 2n;
        }
        console.log(p); //71907725394492636309172207631560989344719079157692262909372032463093070322200385253083390//92896301440844804555194855734306351590752576664899713897225578964975110715736994619411052//08878404984376477812331808340023075352602729369851525895652442163308948653402042738345192//959788983753918865219341425318496896548864n

10.BigInt 函数

js提供BigInt函数，可以用它生成 BigInt 类型的数值。

        console.log(BigInt(666)) //666n
        console.log(BigInt('666')) //666n
        console.log(BigInt(false)) //0n
        console.log(BigInt(true)) //0n

BigInt()函数必须有参数，而且参数必须可以正常转为数值,否则会报错

        console.log(BigInt()) //Cannot convert undefined to a BigInt
        console.log(BigInt(null)) //Cannot convert null to a BigInt
        console.log(BigInt('666a')) // Cannot convert 666a to a BigInt
        console.log(BigInt('1.5')) // Cannot convert 666a to a BigInt
        console.log(BigInt('1.5')) //Cannot convert 1.5 to a BigInt

BigInt.prototype.toString()方法

        console.log(123n.toString()) //123
        console.log(typeof 123n.toString()) //string

BigInt.prototype.valueOf()

        console.log(123n.valueOf()) //123n
        console.log(typeof 123n.valueOf()) //bigint

BigInt.prototype.toLocaleString()

        console.log(126666663n.toLocaleString()) //126,666,663
        console.log(typeof 125555553n.toLocaleString()) //string

数据转换规则

可以使用Boolean()、Number()和String()这三个方法，将 BigInt 可以转为布尔值、数值和字符串类型。

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

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

        console.log(!0n) // true
        console.log(!1n) // false

数学运算方面，BigInt 类型的+、-、*和**这四个二元运算符，与 Number 类型的行为一致。
除法运算/会舍去小数部分，返回一个整数。
注意：
BigInt 不能使用不带符号的右移位运算符>>>
BigInt 不能使用一元的求正运算符+
BigInt 不能与普通数值进行混合运算。
BigInt 对应的布尔值，与 Number 类型一致，即0n会转为false，其他值转为true。

        if (0n) {
            console.log('if');
        } else {
            console.log('else');
        }
        // else

比较运算符（比如>）和相等运算符（==）允许 BigInt 与其他类型的值混合计算，因为这样做不会损失精度。

        console.log(0n < 1) //true
        console.log(0n < true)  //true
        console.log(0n == 0)    //true
        console.log(0n == false) //true
        console.log(0n === 0)   //false

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

 console.log(123n+'哈哈')