ES6标准入门 第五章：数值的扩展

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

二进制前缀：0b（或0B）；   八进制前缀：0o（或0O）。

注意：ES5的严格模式 和 ES6中不再允许使用 0  表示八进制。

将二进制和八进制数值转换为十进制数值，用Number 方法：

Number('0b111'); // 7
number('0o10');   // 8

---

2、Number.isFinite() 、Number.isNaN()

ES6将全局方法isFinite()  和 isNaN() 移植到Number对象上来检查Infinite 和 NaN 这两个特殊值。

新方法与传统的全局方法的区别： 传统方法先将非数值转换为数值再进行判断；新方法只对数值有效，非数值直接返回false 。

（1）Number.isFinite() 检查一个数是否有穷；   【finite--有穷】

Number.isFinite(15); 　　　 　// true
Number.isFinite(0.8); 　　　　// true
Number.isFinite(NaN); 　　　　// false
Number.isFinite(Infinite);   // false
Number.isFinite(-Infinite);  // false
Number.isFinite('15');       // false
Number.isFinite(true);       // false

ES5的实现：

(function (global) {
    var global_isFinite = global.isFinite;
    
    Object.defineProperty(Number, 'isFinite', {
         value: function isFinite(value) {
             return typeof value == 'number' && global_isFinite(value);
         }, 
         configurable: true,
         enumerable: false,
         writable: rue  
    })  
})(this);

（2）Number.isNaN() 检查一个值是否为NaN；  

Number.isNaN(NaN);             // true
Number.isNaN('true'/0);        // true
Number.isNaN('true'/'true');   // true
Number.isNaN(9/NaN);           // true
Number.isNaN(15);             // false
Number.isNaN('15');           // false
Number.isNaN(true);           // false                            

ES5的实现：

(function (global) {
    var global_isNaN = global.isNaN;
    
    Object.defineProperty(Number, 'isNaN', {
         value: function isNaN(value) {
             return typeof value == 'number' && global_isNaN(value);
         }, 
         configurable: true,
         enumerable: false,
         writable: rue  
    })  
})(this);

---

3、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

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

---

 

4、Number.isInteger()

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

在JavaScript内部，整数和浮点数是相同的存储方法，所以3 和 3.0  被视为同一个值！！！

Number.isInteger(25);  　　//true
Number.isInteger(25.0);   //true
Number.isInteger(25.1);   //false
Number.isInteger("15");   //false
Number.isInteger(true);   //false

ES5的实现：

(function (global) {
    var floor = Math.floor,
          isFinite = global.isFinite;
    
    Object.defineProperty(Number, 'isInteger', {
         value: function isInteger(value) {
             return typeof value == 'number' && 
                       isFinite(value) && 
                       value > -9007199254740992 && 
                       value < 9007199254740992 && 
                       floor(value) = value;
         }, 
         configurable: true,
         enumerable: false,
         writable: rue  
    })  
})(this);    

---

5、 Number.EPSILON

ES6 在Number对象上新增了一个极小常量—— Number.EPSILION。

引入极小常量的目的：为浮点数设置一个误差范围。计算误差小于Number.EPSILON，我们就认为得到了正确的结果。

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

为浮点数的运算 书写一个误差检查函数。

function withinErrorMargin (left, right) {
   return Math.abs(left - right) < Number.EPSILON;
}

withinErrorMargin (0.1+0.2 , 0.3); // true
withinErrorMargin (0.2+0.2 , 0.3); // false

---

6、安全整数 和 Number.isSafeInteger()

JavaScript 能够精确的表示的整数范围： -2^{53} 到 2^{53}之间（不含两个端点）；超出之后就无法精确表示。

Math.pow(2, 53) === Math.pow(2, 53)+1;  //true

ES6引入了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.isSafeInteger() 用来判断一个整数是否落在这个范围内。   

Number.isSafeInteger(‘a’)；　　    //false
Number.isSafeInteger(null)；      //false
Number.isSafeInteger(NaN)；       //false
Number.isSafeInteger(‘Infinity)； //false

Number.isSafeInteger(3)；　　      //true
Number.isSafeInteger(3.3)；       //false
Number.isSafeInteger(9007199254740992)； //false 

Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1)； //false 

Number.isSafeInteger(Number.MAX_SAFE_INTEGER)；     //true 

 注意： 不能知识验证结果，而要同时验证参与运算的每个值。

Number.isSafeInteger(9007199254740993)； //false 

Number.isSafeInteger(990)； //true 

Number.isSafeInteger(9007199254740993 - 990)； //true(这里得到了一个错误的结果)

// 返回解果 9007199254740002  但实际应该是 9007199254740003

这是因为9007199254740993超出了精度范围，导致在计算机内部是以 9007199254740992 的形式存储。

9007199254740993 === 9007199254740992；  // true

---

7、Math对象的扩展

（1）Math.trunc()

Math.trunc() 方法用于去除一个小数的小数部分，返回整数部分。

Math.trunc(4.1) // 4
Math.trunc(-4.1) // -4
Math.trunc(-0.1234) // -0

对于非数值，内部先通过Number方法将其转换为数值。

Math.trunc('123.456') // 123
Math.trunc(true) //1
Math.trunc(false) // 0
Math.trunc(null) // 0

对于空值或无法截取整数的值，返回NaN

Math.trunc(NaN);      // NaN
Math.trunc('foo');    // NaN
Math.trunc();         // NaN
Math.trunc(undefined) // NaN

没有部署此方法的环境，用以下代码模拟：

Math.trunc = Math.trunc || function(x) {
     return x<0 ? Math.ceil(x) ? Math.floor(x);
}

（2）Math.sign()

Math.sign() 方法用于判断一个数是正书、负数， 还是零。 对于非数值，会将其先通过Number方法转化为数值。

它会返回5种值：

• 　　参数为正数： 返回+1
• 　　参数为负数： 返回-1
• 　　参数为0    ：  返回0
• 　　参数为-0  ：  返回-0
• 　　其它值    ：   返回NaN

Math.sign('')  // 0
Math.sign(true)  // +1
Math.sign(false)  // 0
Math.sign(null)  // 0
Math.sign('9')  // +1
Math.sign('foo')  // NaN
Math.sign()  // NaN
Math.sign(undefined)  // NaN

没有部署此方法的环境，用以下代码模拟：

Math.sign = Math.sign || function(x) {
   x = +x;
   if( x==0 || isNaN(x) ) {
       return x;     
   }   
   return x>0 ？ 1  : -1; 

} 

（3）Math.cbrt()

Math.cbrt() 用于计算一个数的立方根。  对于非数值，会将其先通过Number方法转化为数值。

Math.cbrt(-1) // -1
Math.cbrt(0)  // 0
Math.cbrt('8') // 2
Math.cbrt('hello') // NaN

没有部署此方法的环境，用以下代码模拟：

Math.cbrt = Math.cbrt || function(x) {
    var y = Math.pow( Math.abs(x), 1/3 );
    return x<0 ? -y : y; 
}

（4）Math.hypot()

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

对于非数值，会将其先通过Number方法转化为数值。只要有一个参数不能转化为数值，就返回NaN。

Math.hypot(3, 4);        // 5
Math.hypot(3, 4, 5);     // 7.0710678118654755
Math.hypot();            // 0
Math.hypot(3, 4, 'foo'); // NaN

（5）Math.clz32()

JavaScript 的整数使用 32 位二进制形式表示，Math.clz32方法返回一个数的 32 位无符号整数形式有多少个前导 0。 

Math.clz32(0) // 32 ---- 0 的二进制形式全为 0
Math.clz32(1) // 31 ---- 1 的二进制形式是0b1
Math.clz32(1000) // 22 ---- 1000 的二进制形式是0b1111101000
Math.clz32(0b01000000000000000000000000000000) // 1
Math.clz32(0b00100000000000000000000000000000) // 2

左移运算符（<<）与Math.clz32方法直接相关。

Math.clz32(1) // 31
Math.clz32(1 << 1) // 30
Math.clz32(1 << 2) // 29
Math.clz32(1 << 29) // 2

对于小数， Math.clz 只考虑整数部分

Math.clz32(3.2) // 30
Math.clz32(3.9) // 30

（6）Math.imul()

 Math.imul方法返回两个数以 32 位带符号整数形式相乘的结果，返回的也是一个 32 位的带符号整数。

（7）Math.fround()

Math.fround方法返回一个数的32位单精度浮点数形式。

（8）对数方法

（9）三角函数方法

---

8、指数运算符——ES7

指数运算符（**）

2 ** 2 // 4
2 ** 3 // 8

指数运算符 与 等号结合，形成一个新的赋值运算符（**=）

let a =2;
a ** =2;  // 等同于 a = a*a；

let b = 3;
b **= 3;  //  等同于b = b*b*b;