1. 箭头函数表达式的语法比函数表达式短，并且不绑定自己的 this，arguments，super或 new.target。此外，箭头函数最好在非方法函数中使用，且不能用作构造函数。

语法

基础语法

  1. (param1, param2, …, paramN) => { statements }
  2. (param1, param2, …, paramN) => expression
  3. // 等价于:  => { return expression; } 
  4. // 如果只有一个参数，圆括号是可选的:
  5. (singleParam) => { statements }
  6. singleParam => { statements }
  7. // 无参数或者多参数的箭头函数需要使用圆括号或者下划线:
  8. () => { statements } _ => { statements }

高级语法

  1. // 只返回一个对象字面量,没有其他语句时, 应当用圆括号将其包起来:
  2. params => ({foo: bar})
  3. // 支持 Rest parameters 和 default parameters:
  4. (param1, param2, ...rest) => { statements }
  5. (param1 = defaultValue1, param2, …, paramN = defaultValueN) => { statements }
  6. // 支持参数列表中的解构赋值
  7. var f = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + c;
  8. f();  // 6

描述

  1. 箭头函数的引入有两个方面的作用：一是更简短的函数书写，二是对 this的词法解析。

更短的函数

更短的函数在函数式编程里很受欢迎。试比较：

  1. var a = [
  2.   "Hydrogen",
  3.   "Helium",
  4.   "Lithium",
  5.   "Beryl­lium"
  6. ];
  7. var a2 = a.map(function(s){ return s.length });
  8. var a3 = a.map( s => s.length );

不绑定 this

  1. 在箭头函数出现之前，每个新定义的函数都有其自己的 this 值（例如，构造函数的 this 指向了一个新的对象；严格模式下的函数的 this 值为 undefined；如果函数是作为对象的方法被调用的，则其 this 指向了那个调用它的对象）。在面向对象风格的编程中，这会带来很多困扰。
  1. function Person() {
  2.   // 构造函数 Person() 定义的 `this` 就是新实例对象自己
  3.   this.age = 0;
  4.   setInterval(function growUp() {
  5.     // 在非严格模式下，growUp() 函数定义了其内部的 `this`为全局对象, 
  6.       不同于构造函数Person()的定义的 `this`
  7.     this.age++; 
  8.   }, 1000);
  9. }
  10. var p = new Person();
  11. // 在 ECMAScript 3/5 中，这个问题通过把this的值赋给变量，
  12. // 然后将该变量放到闭包中来解决。
  13. function Person() {
  14.   var self = this; // 也有人选择使用 `that` 而非 `self`. 
  15.                    // 只要保证一致就好.
  16.   self.age = 0;
  17.   setInterval(function growUp() {
  18.     // 回调里面的 `self` 变量就指向了期望的那个对象了
  19.     self.age++;
  20.   }, 1000);
  21. }

除此之外，还可以使用 bind 函数，把期望的 this 值传递给 growUp() 函数。
箭头函数会捕获其所在上下文的 this 值，作为自己的 this 值，因此下面的代码将如期运行。

  1. function Person(){
  2.   this.age = 0;
  3.   setInterval(() => {
  4.     this.age++; // this正确地指向了person对象
  5.   }, 1000);
  6. }
  7. var p = new Person();

与严格模式的关系

考虑到 this 是词法层面上的，严格模式中与 this 相关的规则都将被忽略。

  1. var f = () => {'use strict'; return this};
  2. f() === window; // 或全局对象

严格模式的其他规则依然不变.

使用 call 或 apply 调用

由于 this 已经在词法层面完成了绑定，通过 call() 或 apply() 方法调用一个函数时，只是传入了参数而已，对 this 并没有什么影响：

  1. var adder = {
  2.   base : 1,
  3.   add : function(a) {
  4.     var f = v => v + this.base;
  5.     return f(a);
  6.   },
  7.   addThruCall: function(a) {
  8.     var f = v => v + this.base;
  9.     var b = {
  10.       base : 2
  11.     };
  12.     return f.call(b, a);
  13.   }
  14. };
  15. console.log(adder.add(1));         // 输出 2
  16. console.log(adder.addThruCall(1)); // 仍然输出 2（而不是3）

不绑定参数（arguments）

  1. 箭头函数不会在其内部暴露出参数（arguments )： arguments.length, arguments[0], arguments[1] 等等，都不会指向箭头函数的 arguments，而是指向了箭头函数所在作用域的一个名为 arguments 的值（如果有的话，否则，就是 undefined。）
  1. var arguments = 42;
  2. var arr = () => arguments;
  3. arr(); // 42
  4. function foo() {
  5.   var f = (i) => arguments[0]+i; // foo函数的间接参数绑定
  6.   return f(2);
  7. }
  8. foo(1); // 3
  9. // 箭头函数没有自己的 arguments ，
  10. // 不过在大多数情形下，rest参数可以给出一个解决方案：
  11. function foo() { 
  12.   var f = (...args) => args[0]; 
  13.   return f(2); 
  14. }
  15. foo(1); // 2

像方法一样使用箭头函数

如上所述，箭头函数表达式对非方法函数是最合适的。让我们看看当我们试着把它们作为方法时发生了什么。

  1. 'use strict';
  2. var obj = {
  3.   i: 10,
  4.   b: () => console.log(this.i, this),
  5.   c: function() {
  6.     console.log( this.i, this)
  7.   }
  8. }
  9. obj.b(); // undefined, Window
  10. obj.c(); // 10, Object {...}
  11. // 箭头函数没有定义this绑定。
  12. // 另一个涉及Object.defineProperty():的示例：
  13. 'use strict';
  14. var obj = {
  15.   a: 10
  16. };
  17. Object.defineProperty(obj, "b", {
  18.   get: () => {
  19.     console.log(this.a, typeof this.a, this);
  20.     return this.a+10; 
  21.     // represents global object 'Window', 
  22.     // therefore 'this.a' returns 'undefined'
  23.   }
  24. });

使用 new 操作符

箭头函数不能用作构造器，和 new 一起用就会抛出错误。

  1. var Foo = () => {};
  2. var foo = new Foo(); // TypeError: Foo is not a constructor

使用原型属性

箭头函数没有原型属性。

  1. var Foo = () => {};
  2. console.log(Foo.prototype); // undefined

使用 yield 关键字

yield 关键字通常不能在箭头函数中使用（除非是嵌套在允许使用的函数内）。因此，箭头函数不能用作生成器。

函数主体

箭头函数既支持简写也支持常规编写。
简写时只需要一个表达式和一个返回值。常规编写时必须有一个明确的返回值。

  1. var func = x => x * x;                  
  2. // 简写函数 省略return
  3. var func = (x, y) => { return x + y; }; 
  4. //常规编写 明确的返回值

返回文字表达式

请牢记，用 params => {object:literal} 这种简单的语法返回一个文字表达式是行不通的：

  1. var func = () => {  foo: 1  };
  2. // undefined!
  3. var func = () => {  foo: function() {}  };
  4. // SyntaxError: function statement requires a name（未定义函数语句）
  5. // 这是因为花括号（即 {} ）里面的代码被解析为序列语句了
  6. //（例如， foo 被认为是一个标签, 而非文字表达式的组成部分）。

所以，记得用圆括号把文字表达式包起来：
var func = () => ({ foo: 1 });

换行

箭头函数在参数和箭头之间不能换行哦

  1. var func = ()
  2. => 1; // SyntaxError: expected expression, got '=>'

解析顺序

在箭头函数中的箭头不是操作符(或者运算符,就像’+ -‘那些)， 但是箭头函数有特殊的解析规则就是：相比普通的函数，受操作符的优先级影响。

  1. let callback;
  2. callback = callback || function() {}; // ok
  3. callback = callback || () => {};      
  4. // SyntaxError:非法箭头函数属性
  5. callback = callback || (() => {});    // ok

示例

  1. // 一个空箭头函数,返回 undefined
  2. let empty = () => {};
  3. (() => "foobar")() // 返回 "foobar" 
  4. var simple = a => a > 15 ? 15 : a; 
  5. simple(16); // 15
  6. simple(10); // 10
  7. let max = (a, b) => a > b ? a : b;
  8. // 简单的数组筛选（数组filter方法），运算（数组map方法）, ...
  9. var arr = [5, 6, 13, 0, 1, 18, 23];
  10. var sum = arr.reduce((a, b) => a + b);  // 66
  11. var even = arr.filter(v => v % 2 == 0); 
  12. // [6, 0, 18] 
  13. var double = arr.map(v => v * 2);       
  14. // [10, 12, 26, 0, 2, 36, 46] 
  15. // 更多简明的promise链
  16. promise.then(a => {
  17.   // ...
  18. }).then(b => {
  19.    // ...
  20. });
  21. // 更易理解的无参数箭头函数
  22. setTimeout( () => {
  23.   console.log('I happen sooner');
  24.   setTimeout( () => {
  25.     // deeper code
  26.     console.log('I happen later');
  27.   }, 1);
  28. }, 1);

转自：https://microzz.com/2017/04/29/arrowfunc/