ES6学习笔记八(数值的扩展)

一、二进制和八进制表示

      ES6提供了二进制和八进制数值的新写法，分别用前缀0b(或0B)和0o(或0O)表示。

//二进制和八进制转化为十进制
Number('0b111'); //7
Number('0o10'); //8

二、Number.isFinite()和Number.isNaN()

      1、Number.isFinite() 检查一个数值是否为有限的

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

      2、Number.isNaN() 检查一个值是否为NaN

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

      3、全局下的isNaN()、isFinite()与Number对象下的isNaN()、isFinite()的区别。

//全局下调用会向执行Number()将非数值转化为数值，再进行判断。
//Number对象下只对数值有效，对非数值一律返回false。
//Number.isNaN()只有对于NaN才返回true

isFinite("25"); //true
Number.isFinite("25"); //false

isNaN("NaN"); //true
Number.isNaN("NaN"); //false

三、Number.parseInt()和Number.parseFloat()

//跟全局方法一样，只是将其模块化
parseInt('12.34');       //12
parseFloat('123.45');   //123.45

Number.parseInt('12.34');     //12
Number.parseFloat('123.45'); //123.45

Number.parseInt === parseInt; //true
Number.parseFloat === parseFloat; //true

四、Number.isInteger()

      判断一个值是否为整数。

//在javascript中整数和浮点数是同样的存储方式，所以25和25.0被视为同一个值
Number.isInteger(25); //true
Number.isInteger(25.0); //true

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

五、Number.EPSILON

      Number对象的一个极小的常量——2.220446049250313e-16
      目的：如果这个误差能够小于Number.EPSILON，我们将可以认为得到了正确结果。

//比如：0.1+0.2=0.30000000000000004(浮点数计算是不精确的)

//检查误差函数
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

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

      1、JavaScript能够精确表示的整数范围是-2的53次方到2的53次方之间，不包含边界。

//2的53次方 => 9007199254740992

Math.pow(2,53) === Math.pow(2,53)+1; // true
//Math.pow(2,53)+1已经超出所能精确的范围

//2的53次方 => Number.MAX_SAFE_INTEGER
//-2的53次方 =>Number.MIN_SAFE_INTEGER

      2、安全整数 Number.isSafeInteger() 判断该数值是否可精确。

Number.isSafeInteger('a'); //false
Number.isSafeInteger(null); //false
Number.isSafeInteger(NaN); //false
Number.isSafeInteger(Infinity); //false
Number.isSafeInteger(-Infinity); //false

Number.isSafeInteger(Number.MIN_SAFE_INTEGER-1); //false
Number.isSafeInteger(Number.MAX_SAFE_INTEGER+1); //false

      注意：不能只是单单验证结果是否在精确范围内，而是要验证每个参与运算的数值。

Number.isSafeInteger(9007199254740993); //false
Number.isSafeInteger(990); //true;

Number.isSafeInteger(9007199254740993-990); //true
//计算结果为：9007199254740002
//正确结果为：9007199254740003

//原因：9007199254740993超出范围，计算机按9007199254740992进行存储。
9007199254740993 ===9007199254740992; //true

七、Math对象的扩展

      1、Math.trunc() => 去除一个数的小数部分，返回整数部分

Math.trunc(4.2);  //4
Math.trunc(4.9);  //4
Math.trunc(-4.1);  //-4
Math.trunc(-4.9);  //-4
Math.trunc(-0.123456);  //-0

      2、Math.sign() => 判断一个数到底是正数、负数、还是零。对非数值，会将其转化为数值

参数类型	返回值
正数	+1
负数	-1
0	0
-0	-0
其他值	NaN

Math.sign(-5); //-1
Math.sign(5); //+1
Math.sign(0); //0
Math.sign(-0); //-0
Math.sign(NaN); //NaN
Math.sign('9'); //+1
Math.sign('foo');//NaN
Math.sign(); //NaN

      3、Math.cbrt() => 计算一个数的立方根,如果为非数值，会将其转化为数值

Math.cbrt(-1); //-1
Math.cbrt(0); //0
Math.cbrt(1); //1
Math.cbrt(2); //1.2599210498948734

Math.cbrt('8'); //2
Math.cbrt('hello'); //NaN

      4、Math.clz32() => 返回一个数的32为无符号整数形式有多少个前导0，即一个数转化为23位二进制时，有多少个前导0。如果为非数值，会将其转化为数值

Math.clz32(0); //32
Math.clz32(1); //31
Math.clz32(1000); //22
Math.clz32(0b01000000000000000000000000000000); //1
Math.clz32(0b00100000000000000000000000000000); //2

      注意一：该方法和左移运算符直接相关联。

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

      注意二：只考虑整数部分

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

      注意三：非数值转化为数值

Math.clz32(); //32
Math.clz32(NaN); //32
Math.clz32(Infinity); //32
Math.clz32(null); //32
Math.clz32('foo'); //32
Math.clz32([]); //32
Math.clz32({}); //32
Math.clz32(true); //31

      5、Math.imul() => 返回两个数以32位带符号整数形式相乘的结果

Math.imul(2,4);  //8
Math.imul(-1,8);  //-8
Math.imul(-2,-2); //4

      6、Math.fround() => 返回一个数的单精度浮点数形式

Math.fround(0); //0
Math.fround(1); //1
Math.fround(1.337); //1.3370000123977661
Math.fround(1.5); //1.5
Math.fround(NaN); //NaN

      7、Math.hypot() => 返回所有参数的平方和的平方根

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

      8、Math.expml(e) => 返回e的x次方后，在减一
      9、Math.log1p(x) => 返回ln(x+1),即Math.log(1+x) 如果x小于-1，则返回NaN

Math.log1p(0); //0
Math.log1p(-1); //-Infinity
Math.log1p(-2); //NaN

      10、Math.log10(x) =>返回以10为底的x的对数。如果x小于-1，则返回NaN
      11、Math.log2(x) =>返回以2为底的x的对数。如果x小于-1，则返回NaN
      12、双曲线函数

Math.sinh(x); //sinx
Math.cosh(x); //cosx
Math.tanh(x); //tanx
Math.asinh(x); //arcsinx
Math.acosh(x); //arccosx
Math.atanh(x); //arctanx

      13、指数运算符

2 ** 2 //2的2次方
2 ** 3 //2的3次方

let a=4;
a **=3;//a=a*a*a

      注意点：Math.pow()与运算符的实现不相同，对于特别大的运算结果，两者还是有细微差别。

欢迎访问我的个人博客