ES6箭头函数适用于什么地方，使用要注意什么

简介

箭头函数表达式的语法比函数表达式更简洁，并且没有自己的this，arguments，super或new.target。箭头函数表达式更适用于那些本来需要匿名函数的地方，并且它不能用作构造函数。 ---- MDN

基础用法

参数表示

(param1, param2, …, paramN) =>
 {
 statements }
    
(param1, param2, …, paramN) =>
     expression
//相当于：(param1, param2, …, paramN) =>
{
     return expression;
 }
    

// 当只有一个参数时，圆括号是可选的：
(singleParam) =>
 {
 statements }
    
singleParam =>
 {
 statements }
    

// 没有参数的函数应该写成一对圆括号。
() =>
 {
 statements }
    

返回值表示

let add1 = (num1, num2) =>
 {

  num1 + num2
}
    ;
    
let add2 = (num1, num2) =>
 {

  return num1 + num2
}
    ;
    
let add3 = (num1, num2) =>
     (num1 + num2);
    
let add4 = (num1, num2) =>
     num1 + num2;
    

console.log(add1(2, 3));
      // undefined
console.log(add2(2, 3));
     // 5
console.log(add3(2, 3));
     // 5
console.log(add4(2, 3));
     // 5

进阶

//加括号的函数体返回对象字面量表达式：
let func = () =>
 ({
foo: 'bar'}
    )
console.log(func());
 // {
foo: 'bar'}
    


//支持剩余参数和默认参数
(param1, param2, ...rest) =>
 {
 statements }
    
(param1 = defaultValue1, param2, …, paramN = defaultValueN) =>
 {

statements }


//同样支持参数列表解构
let f = ([a, b] = [1, 2], {
x: c}
 = {
x: a + b}
    ) =>
     a + b + c;
    
f();
  // 6

this

最佳实践

• 如果必须使用匿名函数，或者inline 回调函数，使用箭头函数。eslint: prefer-arrow-callback, arrow-spacing

why?语法更简洁，并且this更符合预期
如果函数逻辑相当复杂，应当使用命名函数

// bad[1, 2, 3].map(function (x) {
    
  const y = x + 1;
    
  return x * y;
}
    );
    // good[1, 2, 3].map((x) =>
 {
    
  const y = x + 1;
    
  return x * y;
}
    );
    

• 如果函数体只有一条语句，且该语句不会产生副作用。使用简写方式，隐式返回；或者使用完整写法，显式return。
  eslint: arrow-parens, arrow-body-style

// bad
[1, 2, 3].map(number =>
 {
    
  const nextNumber = number + 1;

  `A string containing the ${
nextNumber}
    .`;

}
    );
    

// good
[1, 2, 3].map(number =>
 `A string containing the ${
number}
    .`);
    

// good
[1, 2, 3].map((number) =>
 {
    
  const nextNumber = number + 1;

  return `A string containing the ${
nextNumber}
    .`;

}
    );
    

// good
[1, 2, 3].map((number, index) =>
 ({

  [index]: number,
}
    ));


// No implicit return with side effects
function foo(callback) {
    
  const val = callback();

  if (val === true) {

    // Do something if callback returns true
  }

}
    

let bool = false;
    

// bad
foo(() =>
     bool = true);
    

// good
foo(() =>
 {
    
  bool = true;

}
    );
    

• 当表达式占多行时，使用括号括起来增强可读性

why?函数开头和结束更明确

// bad['get', 'post', 'put'].map(httpMethod =>
     Object.prototype.hasOwnProperty.call(
    httpMagicObjectWithAVeryLongName,
    httpMethod,
  ));
    // good['get', 'post', 'put'].map(httpMethod =>
     (
  Object.prototype.hasOwnProperty.call(
    httpMagicObjectWithAVeryLongName,
    httpMethod,
  )));
    

• 如果函数只有一个参数，省略括号，省略花括号。否则，一直使用完整写法，保持一致性。eslint: arrow-parens

// bad[1, 2, 3].map((x) =>
     x * x);
    // good[1, 2, 3].map(x =>
     x * x);
    // good[1, 2, 3].map(number =>
 (
  `A long string with the ${
number}
    . It’s so long that we don’t want it to take up space on the .map line!`));
    // bad[1, 2, 3].map(x =>
 {
    
  const y = x + 1;
    
  return x * y;
}
    );
    // good[1, 2, 3].map((x) =>
 {
    
  const y = x + 1;
    
  return x * y;
}
    );
    

• 使用无歧义的=> 语法，与=,> =区分开。eslint: no-confusing-arrow

// badconst itemHeight = item =>
     item.height >
     256 ? item.largeSize : item.smallSize;
    // badconst itemHeight = (item) =>
     item.height >
     256 ? item.largeSize : item.smallSize;
    // goodconst itemHeight = item =>
     (item.height >
     256 ? item.largeSize : item.smallSize);
    // goodconst itemHeight = (item) =>
 {

  const {
 height, largeSize, smallSize }
     = item;
    
  return height >
     256 ? largeSize : smallSize;
    

简单结论

• 箭头函数不能用new来创建构造函数的实例，普通函数可以（因为箭头函数创建的时候程序不会为它创建construct方法，也就是没有构造能力，用完就丢掉了，不像普通函数重复利用，因此也不需要构造函数原型，也就是不会自动生成prototype属性）

• 程序不会给箭头函数创建arguments对象

• 普通函数中的this是动态的，而箭头函数中的this指向的是紧紧包裹箭头函数的那个对象（定义时决定的）

• 箭头函数不能通过bind、call、apply来改变this的值，但依然可以调用这几个方法（只是this的值不受这几个方法控制）