ES6 数值的扩展

 1.Number.isFinite()、Number.isNaN();

 es5 isFinite方法返回一个布尔值，表示某个值是否为正常的数值。

{

isFinite(Infinity) // false

isFinite(-Infinity) // false

isFinite(NaN) // false

isFinite(undefined) // false

isFinite(null) // true

isFinite(-1) // true

}

 除了Infinity、-Infinity、NaN和undefined这几个值会返回false，isFinite对于其他的数值都会返回true。

 es6 Number.isFinite()用来检查一个数值是否为有限的（finite），即不是Infinity。

{

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

}

 es5可以通过下面的代码部署Number.isFinite方法

{

 

}

 Number.isNaN()用来检查一个值是否为NaN

 es5 isNaN方法可以用来判断一个值是否为NaN。

{

isNaN(NaN) // true

isNaN(123) // false

}

isNaN只对数值有效，如果传入其他值，会被先转成数值。比如，传入字符串的时候，字符串会被先转成NaN，所以最后返回true，这一点要特别引起注意。也就是说，isNaN为true的值，有可能不是NaN，而是一个字符串。

 出于同样的原因，对于对象和数组，isNaN也返回true。

{

isNaN('Hello') // true

// 相当于

isNaN(Number('Hello')) // true



isNaN({}) // true

// 等同于

isNaN(Number({})) // true



isNaN(['xzy']) // true

// 等同于

isNaN(Number(['xzy'])) // true

}

 对于空数组和只有一个数值成员的数组，isNaN返回false。

{

isNaN([]) // false

isNaN([123]) // false

isNaN(['123']) // false

}

 上面代码之所以返回false，原因是这些数组能被Number函数转成数值

因此，使用isNaN之前，最好判断一下数据类型。

function myIsNaN(value) {

return typeof value === 'number' && isNaN(value);

}

 判断NaN更可靠的方法是，利用NaN为唯一不等于自身的值的这个特点，进行判断。

function myIsNaN(value) {

return value !== value;

}

es6

{

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

}

 如果参数类型不是NaN，Number.isNaN一律返回false。

 它们与传统的全局方法isFinite()和isNaN()的区别在于，传统方法先调用Number()将非数值的值转为数值，再进行判断，而这两个新方法只对数值有效，Number.isFinite()对于非数值一律返回false, Number.isNaN()只有对于NaN才返回true，非NaN一律返回false。

 

 2.Number.parseInt()、Number.parseFloat()

ES6 将全局方法parseInt()和parseFloat() ，移植到Number对象上面，行为完全保持不变。

 ES5的写法

{

parseInt('12.34') // 12

parseFloat('123.45#') // 123.45

}

 ES6的写法

{

Number.parseInt('12.34') // 12

Number.parseFloat('123.45#') // 123.45

}

 这样做的目的，是逐步减少全局性方法，使得语言逐步模块化。

{

Number.parseInt === parseInt // true

Number.parseFloat === parseFloat // true

}

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

{

Number.isInteger(25) // true

Number.isInteger(25.1) // false

Number.isInteger(25.0)//true

Number.isInteger() // false

Number.isInteger(null) // false

Number.isInteger('15') // false

Number.isInteger(true) // false

}

JavaScript 内部，整数和浮点数采用的是同样的储存方法，所以 25 和 25.0 被视为同一个值。

 es5可以通过下面的代码部署Number.isInteger方法

{

 

}

 

 4.Number.EPSLLON

 新增一个极小的常量Number.EPSILON。根据规格，它表示 1 与大于 1 的最小浮点数之间的差。

 对于 64 位浮点数来说，大于 1 的最小浮点数相当于二进制的1.00..001，小数点后面有连续 51 个零。这个值减去 1 之后，就等于 2 的 - 52 次方。

{

Number.EPSILON === Math.pow(2, -52)

// true

Number.EPSILON

// 2.220446049250313e-16

Number.EPSILON.toFixed(20)

// "0.00000000000000022204"

}

 Number.EPSILON实际上是 JavaScript 能够表示的最小精度。误差如果小于这个值，就可以认为已经没有意义了，即不存在误差了。

 Number.EPSILON可以用来设置“能够接受的误差范围”。比如，误差范围设为 2 的-50 次方（即Number.EPSILON * Math.pow(2, 2)），

即如果两个浮点数的差小于这个值，我们就认为这两个浮点数相等。

因此，Number.EPSILON的实质是一个可以接受的最小误差范围。

{

function withinErrorMargin(left, right) {

return Math.abs(left - right) < Number.EPSILON * Math.pow(2, 2);

}

console.log(0.1 + 0.2 === 0.3); //false

console.log(withinErrorMargin(0.1 + 0.2, 0.3)); //true

}

 上面的代码为浮点数运算，部署了一个误差检查函数

 5.安全整数和 Number.isSafeInteger();

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

 超出 2 的 53 次方之后，一个数就不精确了。

 S6 引入了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

}

 Number.isSafeInteger()则是用来判断一个整数是否落在这个范围之内。

{

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 = function (n) {

return (typeof n === 'number' &&

Math.round(n) === n &&

Number.MIN_SAFE_INTEGER <= n &&

n <= Number.MAX_SAFE_INTEGER);

}

但是实际使用这个函数时，需要注意。验证运算结果是否落在安全整数的范围内，不要只验证运算结果，而要同时验证参与运算的每个值。 下面的函数可以同时验证两个运算数和运算结果。

{

function trusty(left, right, result) {

if (

Number.isSafeInteger(left) &&

Number.isSafeInteger(right) &&

Number.isSafeInteger(result)

) {

return result;

}

throw new RangeError('Operation cannot be trusted!');

}

trusty(9007199254740993, 990, 9007199254740993 - 990)

// RangeError: Operation cannot be trusted!



trusty(1, 2, 3)

}