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

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

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

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

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

Number('0b111'); //

number('0o10');   //

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'); //

parseFloat('123.45#'); // 123.45

//ES6的写法

Number.parseInt('12.34'); //

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

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('')  //

Math.sign(true)  // +1

Math.sign(false)  //

Math.sign(null)  //

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

Math.cbrt('8') //

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

Math.hypot(3, 4, 5);     // 7.0710678118654755

Math.hypot();            //

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

Math.clz32(0b00100000000000000000000000000000) //

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

Math.clz32(1) //

Math.clz32(1 << 1) //

Math.clz32(1 << 2) //

Math.clz32(1 << 29) //

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

Math.clz32(3.2) //

Math.clz32(3.9) //

（6）Math.imul()

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

（7）Math.fround()

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

（8）对数方法

（9）三角函数方法

8、指数运算符——ES7

指数运算符（**）

2 ** 2 //

2 ** 3 //

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

let a =2;

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

let b = 3;

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