ES6传达的一个比较重要的思想，一个是尽可能的减少全局的方法而把它移植到特定的对象上去，另一个是在一些判断的场景下，尽可能的减少隐式的转换使得得到的结果更为安全。

1：二进制、八进制表示法

    /* 0b(0B) 二进制*/
    Number('0b111');  
    //  7
    
    /* 0o(0O) 八进制*/
    Number('0o10');
    //  8

2：Number.isFinite，检查一个数值是否为有限，不做隐式转换

    Number.isFinite(15);
    // true 
    
    Number.isFinite(NaN);
    // false 
    
    Number.isFinite(Infinity);
    // false 
    
    Number.isFinite(true);
    // false 
    
    isFinite("25");
    // true

3：Number.isNaN，检查一个值是否为NaN，不做隐式转换，在浏览器全局的方法中移植的

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

4：Number.parseInt、Number.parseFloat，全局方法移植（不能去掉隐式转换）

5：Number.isInteger，判断一个数值是否为整数，不做隐式转换

    Number.isInteger(25);
    // true 
    
    Number.isInteger('15');
    // false 
     
    Number.isInteger(3.0000000000000002);
    // true 
    
    0.1 + 0.2 === 0.3
    // false
    
    0.1 + 0.2 - 0.3 < Number.EPSILON;
    // true

6：Number.EPSILON，JavaScript 能够表示的最小精度

    Number.EPSILON === Math.pow(2, -52);   //最小精度
    // true
    
    0.1 + 0.2 === 0.3
    // false

7：Number.isSafeInteger，安全 '整数'

    Math.pow(2, 53) === Math.pow(2, 53) + 1
    // true  
    
    Number.isSafeInteger('a');
    // false 
    
    Number.isSafeInteger(null);
    // false 
    
    Number.isSafeInteger(NaN);
    // false 
    
    Number.isSafeInteger(3);
    // true 
    
    Number.isSafeInteger(1.2);
    // false 

8：Math.trunc，去除小数部分，Number隐式转换

    Math.trunc(-4.9);
    // -4 
    
    Math.trunc('123.456');
    // 123 
     
    Math.trunc('week');
    // NAN

9：Math.sign，判断正数、负数与0，Number隐式转换

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

      Math.sign(true);
      // +1 
      
      Math.sign(false);
      // 0 
      
      Math.sign(null);
      // 0 
      
      Math.sign('9');
      // 9 
  

10：Math.cbrt，立方根，Number隐式转换

11：对数方法，Number隐式转换

12：指数运算符

    2 ** 2
    // 4 
    
    2 ** 3
    // 8 
    
    2 ** 3 ** 2    //两个星号代表一个指数越算，从后往前算
    // 2 ** (3 ** 2)