ES6从入门到精通——数值和函数

数值

Number.isFinite(), Number.isNaN()

Number.isFinite()用来检查一个数值是否为有限的，即不是Infinity，为true的时候表示数值是有限的。当参数类型不是数值，Number.isFinite一律返回false。

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

Number.isNaN()用来检查一个值是否为NaN。如果参数类型不是NaN，Number.isNaN一律返回false。

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

它们与传统的全局方法isFinite()和isNaN()的区别在于，传统方法先调用Number()将非数值的值转为数值，再进行判断，而这两个新方法只对数值有效，Number.isFinite()对于非数值一律返回false, Number.isNaN()只有对于NaN才返回true，非NaN一律返回false。

Number.parseInt(),Number.parseFloat()

// ES5的写法
parseInt('12.34') // 12
parseFloat('123.45#') // 123.45

// ES6的写法
Number.parseInt('12.34') // 12
Number.parseFloat('123.45#') // 123.45

Number.isInteger()

Number.isInteger()用来判断一个数值是否为整数。如果参数不是数值，Number.isInteger返回false。

Number.isInteger(25) // true
Number.isInteger(25.0) // true
Number.isInteger() // false
Number.isInteger(null) // false
Number.isInteger('15') // false
Number.isInteger(true) // false

常量Number.EPSILON

Number.EPSILON属性表示 1 与大于 1 的最小浮点数之间的差。大于 1 的最小浮点数相当于二进制的1.00..001，小数点后面有连续 51 个零。这个值减去 1 之后，就等于 2 的 -52 次方。

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

最大/最小安全整、Number.isSafeInteger()

Number.MAX_SAFE_INTEGER和Number.MIN_SAFE_INTEGER表示最大/最小安全整数常量。安全整数范围的上限，即 2 的 53 次方减 1，安全整数范围的下限，即 2 的 53 次方减 1 的负数。

Number.MAX_SAFE_INTEGER === Math.pow(2, 53) - 1
// true
Number.MAX_SAFE_INTEGER === 9007199254740991
// true

Number.MIN_SAFE_INTEGER === -Number.MAX_SAFE_INTEGER
// true
Number.MIN_SAFE_INTEGER === -9007199254740991
// true

Number.isSafeInteger()则是用来判断一个整数是否落在 最大/最小安全整之内。

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

Number.isSafeInteger(3) // true
Number.isSafeInteger(1.2) // false
Number.isSafeInteger(9007199254740990) // true
Number.isSafeInteger(9007199254740992) // false

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

Math 对象的扩展

普通计算

• Math.cbrt：用于计算一个数的立方根。会对非数值进行转换，如果无法进行转化则返回 NaN
• Math.imul：两个数以 32 位带符号整数形式相乘的结果，返回的也是一个 32 位的带符号整数。
• Math.hypot：用于计算所有参数的平方和的平方根。空值会被转换为 0，非数值会先被转换为数值后进行计算，如果无法转化则为返回 NaN；如果为值为Infinity 或 -Infinity则返回 Infinity
• Math.clz32：用于返回数字的32 位无符号整数形式的前导0的个数。当参数为小数时，只考虑整数部分，对于空值或非数值，会转化为数值再进行计算

Math.cbrt(1);  // 1
Math.cbrt('1'); // 1
Math.cbrt('hhh'); // NaN

Math.imul(1, 2);   // 2

Math.hypot(3, 4); // 5
Math.hypot(1, 2, '3'); // 3.741657386773941
Math.hypot();   // 0 
Math.hypot(Infinity); // Infinity
Math.hypot(3, 4, 'foo'); // NaN

Math.clz32(0); // 32
Math.clz32(1); // 31
Math.clz32(0b01000000000100000000000000000000); // 1
Math.clz32(0.5); // 32
Math.clz32('1');       // 31
Math.clz32(-Infinity); // 32
Math.clz32(undefined); // 32
Math.clz32('hhh');     // 32

数字处理

• Math.trunc：用于返回数字的整数部分。整数部分为 0 时也会判断符号，会将非数值转为数值再进行处理；空值或无法转化为数值时时返回 NaN
• Math.fround：用于获取数字的32位单精度浮点数形式。

Math.trunc(12.3); // 12
Math.trunc(-0.5); // -0
Math.trunc("12.3"); // 12
Math.trunc("123.2hhh"); // NaN

Math.fround(1.234) // 1.125

判断

• Math.sign：判断数字的符号（正、负、0）。

Math.sign(1);  // 1
Math.sign(-1); // -1
 
// 参数为 0 时，不同符号的返回不同
Math.sign(0);  // 0
Math.sign(-0); // -0
 
// 判断前会对非数值进行转换
Math.sign('1');  // 1
Math.sign('-1'); // -1  
 
// 参数为非数值（无法转换为数值）时返回 NaN
Math.sign(NaN);   // NaN 
Math.sign('hhh'); // NaN

对数

• Math.expm1()：用于计算 e 的 x 次方减 1 的结果，即 Math.exp(x) - 1 。
• Math.log1p(x)：用于计算1 + x 的自然对数，即 Math.log(1 + x) 。
• Math.log10(x)：用于计算以 10 为底的 x 的对数。
• Math.log2()：用于计算 2 为底的 x 的对数。

双曲函数方法

• Math.sinh(x): 用于计算双曲正弦。
• Math.cosh(x): 用于计算双曲余弦。
• Math.tanh(x): 用于计算双曲正切。
• Math.asinh(x): 用于计算反双曲正弦。
• Math.acosh(x): 用于计算反双曲余弦。
• Math.atanh(x): 用于计算反双曲正切。

指数运算符

指数运算符（**），这个运算符的一个特点是右结合，而不是常见的左结合。多个指数运算符连用时，是从最右边开始计算的。

1 ** 2; // 1
// 右结合，从右至左计算
2 ** 2 ** 3; // 256
// **=
let exam = 2;
exam ** = 2; // 4

函数

函数的参数

在之前的函数中，函数的参数只能在调用的时候赋值，但是在 ES6 中函数有了默认值。给参数赋值默认值，在不给参数传入默认值时，则使用默认参数。只有在未传递参数，或者参数为 undefined 时，才会使用默认参数，null 值被认为是有效的值传递。

function fn(name,age=17){
 console.log(name+","+age);
}
fn("Amy",18);  // Amy,18
fn("Amy","");  // Amy,
fn("Amy");     // Amy,17
fn("Amy",null); // Amy,null

也可以用不定参数用来表示不确定参数个数，形如，…变量名，由…加上一个具名参数标识符组成。具名参数只能放在参数组的最后，并且有且只有一个不定参数。

function f(...values){
    console.log(values.length);
}
f(1,2);      //2
f(1,2,3,4);  //4

name 属性

在ES6 中重新对函数的 name 属性做出了修改，这个属性用于返回该函数的函数名。

var f = function () {};

// ES5
f.name // ""

// ES6
f.name // "f"

const bar = function baz() {};

// ES5
bar.name // "baz"

// ES6
bar.name // "baz"

箭头函数

箭头函数是 ES6 对函数最大的修改。箭头函数提供了一种更加简洁的函数书写方式。基本语法是：`参数 => 函数体。

如果箭头函数不需要参数或需要多个参数，就使用一个圆括号代表参数部分。如果箭头函数的参数只有一个则可以省略圆括号

var f = () =>{ return 5 };
// 等同于
var f = function () { return 5 };

var f = v => { return v; }
//等价于
var f = function(v){
 return v;
}

如果箭头函数的代码块部分多于一条语句，就要使用大括号将它们括起来，并且使用return语句返回。如果箭头函数的代码块部分只有一条语句，且是返回值则可以省略大括号

var sum = (num1, num2) => { return num1 + num2; }
var sum = (num1, num2) =>  num1 + num2

由于大括号被解释为代码块，所以如果箭头函数直接返回一个对象，必须在对象外面加上括号，否则会报错。

// 报错
let getTempItem = id => { id: id, name: "Temp" };

// 不报错
let getTempItem = id => ({ id: id, name: "Temp" });

使用注意点，箭头函数有几个使用注意点。

（1）函数体内的this对象，就是定义时所在的对象，而不是使用时所在的对象。

（2）不可以当作构造函数，也就是说，不可以使用new命令，否则会抛出一个错误。

（3）不可以使用arguments对象，该对象在函数体内不存在。如果要用，可以用 rest 参数代替。

（4）不可以使用yield命令，因此箭头函数不能用作 Generator 函数。