二进制和八进制数值表示法
ES6提供了二进制和八进制数值的新写法，分别前缀 0b(或0B)、 0o(或0O)然后跟上二进制、八进制值即可。
二进制(Binary)表示法新写法：前缀 0b 或 0B。
let binary = 0b010101; // 21
let binary2 = 0B010111; // 23
八进制(Octal)表示法新写法：前缀 0o 或 0O。
let octal = 0o123; // 83
let octal2 = 0O1234; // 668
从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'); // 1992
parseInt(1992.102); // 1992
// ES6新写法
Number.parseInt('1992.1020'); // 1992
Number.parseInt(1992.1020); // 1992
// 指定转换进制时，第二个参数指定的基数(基数可以是10[默认基数，可以不写], 2, 8或 16等进制数)，将字符串参数解析为有符号的整数。
Number.parseInt('0101',2); // 5
Number.parseInt('111',8); // 73
Number.parseInt('222',16); // 546
Number.parseInt('-333',10); // -333
// parseFloat() 和 Number.parseFloat()。两方法都是先判定指定字符串或数字串中的首个字符是否是数字。是，则对该字符串进行解析，直到数字的末端为止，然后以数字格式返回该数字。
// 注：字符串中只返回第一个数字、字符串开头和结尾允许存在空格，但中间如出现空格，则空格后面的数字将不予识别。
// ES5写法
parseFloat('1992.1020abc'); // 1992.102
parseFloat(1992.1020); // 1992.102
parseFloat(' 199 2.1020abc '); // 199
// 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); // 9007199254740992
Math.pow(2, 53)-1; // 9007199254740991
-(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); // 9007199254740991
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
|
