ES6 - 基础学习(5): 数值扩展

二进制和八进制数值表示法

ES6提供了二进制和八进制数值的新写法，分别前缀 0b(或0B)、 0o(或0O)然后跟上二进制、八进制值即可。

　　二进制(Binary)表示法新写法：前缀 0b 或 0B。

　　let binary = 0b010101;        //
　　let binary2 = 0B010111;       //

　　八进制(Octal)表示法新写法：前缀 0o 或 0O。

　　let octal = 0o123;　　　　　　  //
　　let octal2 = 0O1234;      　  //

　　从ES5开始，严格模式下，八进制数值就不再允许用前缀0表示，ES6则进一步明确规定，八进制数值用0o前缀表示。

　　// 非严格模式
　　(function () {
    　　console.log(0o01 === 001);
　　})();
　　// true

　　// 严格模式
　　(function () {
    　　'use strict';
    　　console.log(0o01 === 001);    // Octal literals with prefix '0' are not allowed. Use '0o' prefix instead
　　})();
　　// Uncaught SyntaxError: Octal literals are not allowed in strict mode.

数值的验证、判断、以及转换

　　ES6不仅提供了很多新的数值处理方法，同时还将之前相对零散的全局处理方法都整理到了Number对象里面。

　　数值的验证：Number.isFinite()【用于检查一个数值是否为有限的( finite)，即不是 Infinity】，Number.isNaN()【用于检查一个值是否为NaN】

　　数值的判断：Number.isInteger()【用于判断一个数值是否为整数】，Number.isSafeInteger()【用于判断整数是否在安全整数范围内】

　　数值的转换：Number.parseInt()，Number.parseFloat()

数值的验证：ES6在Number对象内，新提供了 Number.isFinite()和 Number.isNaN()两个方法。

　　1、Number.isFinite()：用于检查一个数值是否为有限的（finite），即不是Infinity。同时Number.isFinite() 没有进行隐式的 Number() 类型转换，所有非数值都返回 false。所以Number.isFinite()还可以用来进行数字验证，只要是数值，不论是整形还是浮点型都会返回 true，非数值则一律返回 false。

　　console.log(Number.isFinite('testDemo'));        // false 字符串
　　console.log(Number.isFinite(1992));              // true  整形数值
　　console.log(Number.isFinite(0.5));               // true  浮点型
　　console.log(Number.isFinite(true));              // false 布尔值
　　console.log(Number.isFinite(null));              // false null
　　console.log(Number.isFinite(undefined));         // false undefined
　　console.log(Number.isFinite([1, 2, 3]));         // false 数组
　　console.log(Number.isFinite({test: 'Demo'}));    // false 对象
　　console.log(Number.isFinite(NaN));               // false NaN
　　console.log(Number.isFinite(Infinity));          // false Infinity
　　console.log(Number.isFinite(-Infinity));         // false -Infinity

　　2、Number.isNaN()：用于检查一个值是否为NaN。若参数类型不是NaN，Number.isNaN() 则一律返回 false，而且 Number.isNaN() 也没有进行隐式的 Number() 类型转换。

　　console.log(Number.isNaN('testDemo'));           // false
　　console.log(Number.isNaN('testDemo'/0));         // true
　　console.log(Number.isNaN('true'/'true'));        // true
　　console.log(Number.isNaN(1992));                 // false
　　console.log(Number.isNaN(1992/0));               // false
　　console.log(Number.isNaN(0.5));                  // false
　　console.log(Number.isNaN(true));                 // false
　　console.log(Number.isNaN(true/0));               // false
　　console.log(Number.isNaN(null));                 // false
　　console.log(Number.isNaN(undefined));            // false
　　console.log(Number.isNaN([1, 2, 3]));            // false
　　console.log(Number.isNaN({test: 'Demo'}));       // false
　　console.log(Number.isNaN(NaN));                  // true
　　console.log(Number.isNaN(1992/NaN));             // true
　　console.log(Number.isNaN(Infinity));             // false
　　console.log(Number.isNaN(-Infinity));            // false

数值的判断：Number.isInteger()【用于判断一个数值是否为整数】，Number.isSafeInteger()【用于判断数值是否在安全范围内】

　　1、Number.isInteger()：用于判断一个数值是否为整数。如果参数不是数值，Number.isInteger()则返回false。

　　console.log(Number.isInteger(0));                     // true
　　// JavaScript内部，整数和浮点数采用同样的储存方法,因此 1 与 1.0 被视为相同的值
　　console.log(Number.isInteger(1));                     // true
　　console.log(Number.isInteger(1.0));                   // true

　　console.log(Number.isInteger(1.1));                   // false
　　console.log(Number.isInteger(Math.PI));               // false
　　// NaN 和正负 Infinity 都不是整数
　　console.log(Number.isInteger(NaN));                   // false
　　console.log(Number.isInteger(Infinity));              // false
　　console.log(Number.isInteger(-Infinity));             // false

　　console.log(Number.isInteger("1992"));                // false
　　console.log(Number.isInteger(true));                  // false
　　console.log(Number.isInteger(false));                 // false
　　console.log(Number.isInteger(null));                  // false
　　console.log(Number.isInteger(undefined));             // false
　　console.log(Number.isInteger([1,2,3]));               // false
　　console.log(Number.isInteger({test: 'Demo'}));        // false

　　// 数值的精度超过53个二进制位(1个隐藏位，52个有效位)时，由于第54位及后面的位被丢弃，JS会产生误判，此时就相当于在判定1.000000000000000，所以会返回true。
　　console.log(Number.isInteger(1.0000000000000001));    // true　　
　　// 同理，当一个数值的绝对值小于Number.MIN_VALUE（5E-324），即小于JavaScript能够分辨的最小值，会被自动转为0，此时JS也会产生误判。
　　console.log(Number.isInteger(5E-324));                // false　　5E-324 还没超出最小值范围，所以isInteger()判定还是false。
　　console.log(Number.isInteger(5E-325));                // true　　 5E-325 由于值太小，超出JS能够分辨的最小值范围，所以被自动转为0，因此isInteger()判定为true。

　　总之，如果对数据的精度要求较高，在进行数据是否为整数进行判定时，不建议使用Number.isInteger()方法。　

　　2、Number.isSafeInteger()：用于判定整数是否在安全整数范围内。

数值的转换：Number.parseInt()，Number.parseFloat()。ES6将之前的全局方法 parseInt() 和 parseFloat() 移植到了Number对象内，行为和之前的全局方法一样。这样将之前的全局方法逐步移植到各个模块内，既减少了全局性方法数量，又使得方法逐步模块化，聚合化。

　　1、Number.parseInt()：用于解析一个字符串，并返回一个整数。

　　2、Number.parseFloat()：用于解析一个字符串，并返回一个浮点数。

　　// 不指定转换进制时，默认为 10 进制
　　// parseInt() 和 Number.parseInt()
　　// ES5写法
　　parseInt('1992.102');                    //
　　parseInt(1992.102);                      //
　　// ES6新写法
　　Number.parseInt('1992.1020');            //
　　Number.parseInt(1992.1020);              //

　　// 指定转换进制时，第二个参数指定的基数(基数可以是10[默认基数，可以不写], 2, 8或 16等进制数)，将字符串参数解析为有符号的整数。
　　Number.parseInt('0101',2);               //
　　Number.parseInt('111',8);                //
　　Number.parseInt('222',16);               //
　　Number.parseInt('-333',10);              // -333

　　// parseFloat() 和 Number.parseFloat()。两方法都是先判定指定字符串或数字串中的首个字符是否是数字。是，则对该字符串进行解析，直到数字的末端为止，然后以数字格式返回该数字。
　　// 注：字符串中只返回第一个数字、字符串开头和结尾允许存在空格，但中间如出现空格，则空格后面的数字将不予识别。
　　// ES5写法
　　parseFloat('1992.1020abc');              // 1992.102
　　parseFloat(1992.1020);                   // 1992.102
　　parseFloat(' 199 2.1020abc ');           //
　　// ES6新写法
　　Number.parseFloat('1992.1020abc');       // 1992.102
　　Number.parseFloat(1992.1020);            // 1992.102
　　Number.parseFloat(' 1992.1 020abc ');    // 1992.1

　　// 当首个字符无法被解析成整数和浮点数时(若首个字符被解析为正负号时，则判定第二个字符的解析结果)，则都返回 NaN
　　Number.parseInt('abc');                  // NaN
　　Number.parseFloat('abc');                // NaN

　　// Number.parseInt()与全局的 parseInt() 方法是同一个方法
　　Number.parseInt === parseInt;            // true
　　// Number.parseFloat()与全局的 parseFloat() 方法也是同一个方法
　　Number.parseFloat === parseFloat;        // true

最大/最小安全数 以及Number.isSafeInteger()

　　安全整数及安全整数范围：安全整数是 JavaScript 中能够精确表示的整数，其范围在 2 的 -53 次方到 2 的 53 次方之间（不包括两个端点，既(-Math.pow(2, 53)，Math.pow(2, 53))），超过这个范围（不论是整数还是小数）JavaScript 都无法精确表示该数了。

　　安全数范围：大小在 2 的 -53 次方到 2 的 53 次方之间（不包括两个端点，既(-Math.pow(2, 53)，Math.pow(2, 53))）的数。

　　最大安全整数：安全整数的上限，即 2 的 53 次方减 1 。　　Math.pow(2, 53)-1;  // 9007199254740992-1

　　最小安全整数：安全整数的下限，即 2 的 53 次方减 1 的负数。　　-(Math.pow(2, 53)-1);  // -(9007199254740992-1)

　　常量：ES6 引入了 Number.MAX_SAFE_INTEGER 和 Number.MIN_SAFE_INTEGER 两个常量，用来表示安全整数的上下限。以便于日常开发过程中 判定数值是否超出安全范围。

　　Math.pow(2, 53);                                 　　//
　　Math.pow(2, 53)-1;                                  //
　　-(Math.pow(2, 53)-1);                            　　// -9007199254740991
　　
　　Math.pow(2, 53) === Math.pow(2, 53) + 0.01;         // true，超出 2 的 53 次方之后，JS就无法精确表示这个值了，哪怕多0.01都不行。
　　-Math.pow(2, 53) === (-Math.pow(2, 53))-0.01;       // true

　　console.log(Number.MAX_SAFE_INTEGER);            　　//
　　console.log(Number.MIN_SAFE_INTEGER);            　　// -9007199254740991

　　console.log(Number.MAX_SAFE_INTEGER === Math.pow(2, 53) - 1);            // true
　　console.log(Number.MIN_SAFE_INTEGER === -(Math.pow(2, 53) - 1));         // true

　　Number.isSafeInteger()：用于判定整数是否在安全整数范围内。

　　// Number.isSafeInteger()用于判定整数是否在安全整数范围内
　　Number.isSafeInteger(Number.MAX_SAFE_INTEGER);         // true
　　Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1);     // false
　　Number.isSafeInteger(Number.MIN_SAFE_INTEGER);         // true
　　Number.isSafeInteger(Number.MIN_SAFE_INTEGER - 1);     // false
　　Number.isSafeInteger(1992);                            // true