ECMAScript 6（8）数值的扩展 (1) Number对象扩展

心已赠人 2021-09-19 13:46 299阅读 0赞

**目录**

数值的扩展

1.  二进制和八进制

2.  数字类型判断

Number.isFinite(), Number.isNaN()

Number.isFinite()

Number.isNaN()

3.  Number.isInteger()  (判断是否整数)

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

5.  新增常量

5.1  极小的常量 Number.EPSILON

5.2.  安全整数范围 Number.isSafeInteger()

--------------------

# 数值的扩展  #

> 1、二进制数字开头0b，八进制数字开头0o  
> 2、更靠谱的类型判断有效数字，NaN，以及整数（es6新增）；  
> 3、增加了一个极小的常量，用于判断浮点数计算，结果的误差小于这个常量则基本可以认为相等；  
> 4、增加了安全范围的最大整数和最小整数常量，以及对他们的判断；  
> 5、新增方法全部不会进行隐式转换；

## 1.  二进制和八进制 ##

> 二进制新的写法，用前缀`0b`（或`0B`）
> 
> 八进制新的写法 ,  用前缀0o ( 0O )

Number(0b11)   // 二进制转换成十进制等于 3
    Number(0o11)   // 八进制转换成十进制等于 9
    
    // ES5转换
    parseInt(11,2)  //3
    parseInt(11,8)  //9
    
    var a = 2;
    a.toString(2);    //"10"这里是将数字转为二进制字符串

##  2.  数字类型判断 ##

### `Number.isFinite(),` `Number.isNaN()` ###

### Number.isFinite() ###

> 1.  准确的说，只有当一个数字是合法数字（非NaN，非Infinity正无穷，必须是number类型）才会返回true。

示例 :

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
    
    var test = {};
    test.toString = function () {
        return 1;
    }
    Number.isFinite(test);  // 不会被隐式转换, false

和传统的全局方法`isFinite()`的区别在于，传统方法先调用`Number()`将非数值的值转为数值，再进行判断，而这两个新方法只对数值有效，

isFinite("1");    //会被隐式转换，true
    isFinite([1]);    //也会被隐式转换，true
    
    var test = {};
    test.toString = function () {
        return 1;
    }
    isFinite(test);    //会被隐式转换，true

###  `Number.isNaN()` ###

> 1.   和上面类似，只对NaN生效。

示例 :

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.isNaN('NaN')  // 不会被隐式转换, false
    
    var test = {};
    test.toString = function () {
        return NaN;
    }
    Number.isNaN(test);    //不会被隐式转换，false

对比全局的isNaN()

isNaN("NaN");    //会被隐式转换，true
    isNaN("NaNabcdef");    //会被隐式转换，true
    
    var test = {};
    test.toString = function () {
        return NaN;
    }
    isNaN(test);    //会被隐式转换，true

>  **总结：**  
> 简单来说，没有Number开头的方法，会先将参数通过Number()隐式转换为数字后，再去判断。（对象会先调用Object.toString()方法转换为字符串）  
> 而通过Number对象来调用的这两个方法，不会进行隐式转换，因此更准确。

##  3.  Number.isInteger()  (判断是否整数) ##

> 1.  判断一个**数值**是否为整数
> 
> 2.  JavaScript 内部，整数和浮点数采用的是同样的储存方法 , 浮点数如果小数部分为0，例如1.000，也会被视为整数

Number.isInteger(1)；    //true
    Number.isInteger(1.00);    //视为1，true
    Number.isInteger(-1.0);    //整数，true
    Number.isInteger(1.01);    //非整数，false
    Number.isInteger(true);    //不会隐式转换，false
    Number.isInteger('1');    //不会隐式转换，false
    Number.isInteger(Infinity);    //正无穷不算是整数，false
    
    var test = {};
    test.toString = function () {
        return 1;
    }
    Number.isInteger(test);    //不会被隐式转换，false

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

> 1.  简单说就是把全局方法移植到 Number 对象上面, 使用完全一样。
> 
> 2.  目的是 逐步减少全局性方法，使得语言逐步模块化

// 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

## 5.  新增常量 ##

### 5.1  极小的常量 Number.EPSILON ###

> 目的用于浮点误差判断

它的值是

Number.EPSILON === Math.pow(2, -52)  // true 2的负52次方
    Number.EPSILON                       // 2.220446049250313e-16
    Number.EPSILON.toFixed(20)           // "0.00000000000000022204"

在于为浮点数计算，设置一个误差范围。我们知道浮点数计算是不精确的。(不仅JavaScript，所有遵循IEEE 754规范的语言都是如此)

s6的解决办法是引入一个误差常量，在计算浮点数时，用于进行判断误差。

具体来说，假如a-b的绝对值，小于这个常量，一般情况下就可以认为a==b，如代码：

0.1 + 0.2
    // 0.30000000000000004
    
    0.1 + 0.2 - 0.3
    // 5.551115123125783e-17
    
    0.1+0.2-0.3 < Number.EPSILON;    //true

阮一峰封装的误差检测函数：(判断两个值是否相等)

//判断两个数是否相等（误差低于一定范围）
    function withinErrorMargin(left, right) {
        //Math.abs的效果是返回绝对值（因为负数必然小于这个常量）
        return Math.abs(left - right) < (Number.EPSILON || Math.pow(2, -52));  // 兼容处理
    }
    
    withinErrorMargin(0.1+0.2, 0.3);    //true

###  5.2.  安全整数范围 Number.isSafeInteger() ###

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

> Number.MAX\_SAFE\_INTEGER 最大的安全整数

其值为2的53次方-1，值为9007199254740991

> Number.MIN\_SAFE\_INTEGER 最小的安全整数

其值为2的53次方+1，值为-9007199254740991

检查一个数字是否是安全整数，可以通过以下方法来判断

> Number.isSafeInteger(变量)

Number.isSafeInteger(1);    //true
    Number.isSafeInteger(Number.MAX_SAFE_INTEGER);    //true
    Number.isSafeInteger(Number.MAX_SAFE_INTEGER - 1);    //true
    Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1);    //超出范围，false
    Number.isSafeInteger(1.1);    //浮点数显然不是整数，更别说是安全整数了，false
    Number.isSafeInteger(1.0);    //视为整数，true
    Number.isSafeInteger('1');    //不会隐式转换，false