JavaScript—箭頭函數

箭頭函數表達式的文法比函數表達式短，并且不綁定自己的 this，arguments，super或 new.target。此外，箭頭函數總是匿名的。這些函數表達式最适合非方法函數，它們不能用作構造函數。

文法EDIT

基礎文法

(param1, param2, …, paramN) => { statements }
(param1, param2, …, paramN) => expression
         // equivalent to:  => { return expression; }

// 如果隻有一個參數，圓括号是可選的:
(singleParam) => { statements }
singleParam => { statements }

// 無參數的函數需要使用圓括号:
() => { statements }
      

進階文法

// 傳回對象字面量時應當用圓括号将其包起來:
params => ({foo: bar})

// 支援 Rest parameters 和 default parameters:
(param1, param2, ...rest) => { statements }
(param1 = defaultValue1, param2, …, paramN = defaultValueN) => { statements }

// 參數清單中的解構指派也是被支援的
var f = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + c;
f();  // 6
      

詳細的文法例子可以參考 這裡。

描述EDIT

另見 "ES6 In Depth: Arrow functions" on hacks.mozilla.org.

箭頭函數的引入有兩個方面的影響：一是更簡短的函數書寫，二是對 

this 

的詞法解析

。

更短的函數

在一些函數式程式設計模式裡，更短的函數書寫方式很受歡迎。試比較：

var a = [
  "Hydrogen",
  "Helium",
  "Lithium",
  "Beryl­lium"
];

var a2 = a.map(function(s){ return s.length });

var a3 = a.map( s => s.length );
           

不綁定 this

在箭頭函數出現之前，每個新定義的函數都有其自己的  

this

 值（例如，構造函數的 this 指向了一個新的對象；嚴格模式下的函數的 

this

 值為 

undefined

；如果函數是作為對象的方法被調用的，則其 this 指向了那個調用它的對象）。在面向對象風格的程式設計中，這被證明是非常惱人的事情。

function Person() {
  // 構造函數 Person() 定義的 `         this` 就是新執行個體對象自己                
  this.age = 0;
  setInterval(function growUp() {
    // 在非嚴格模式下，growUp() 函數定義了其内部的 `this`
    // 為全局對象, 不同于構造函數Person()的定義的 `this`
    this.age++; 
  }, 1000);
}

var p = new Person();      

在 ECMAScript 3/5 中，這個問題可以通過新增一個變量來指向期望的 

this 

對象，然後将該變量放到閉包中來解決。

function Person() {
  var self = this; // 也有人選擇使用 `that` 而非 `self`. 
                   // 隻要保證一緻就好.
  self.age = 0;

  setInterval(function growUp() {
    // 回調裡面的 `self` 變量就指向了期望的那個對象了
    self.age++;
  }, 1000);
}
           

除此之外，還可以使用 bind 函數，把期望的 

this 

值傳遞給 

growUp()

 函數。

箭頭函數則會捕獲其所在上下文的  

this

 值，作為自己的 

this

 值，是以下面的代碼将如期運作。

function Person(){
  this.age = 0;

  setInterval(() => {
    this.age++; // |this| 正确地指向了 person 對象
  }, 1000);
}

var p = new Person();
           

與 strict mode 的關系

考慮到 

this

 是詞法層面上的，嚴格模式中與 

this

 相關的規則都将被忽略。

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

嚴格模式的其他規則依然不變.

使用 call 或 apply 調用

由于 

this

 已經在詞法層面完成了綁定，通過 

call()

 或 

apply()

 方法調用一個函數時，隻是傳入了參數而已，對 

this

 并沒有什麼影響：

var adder = {
  base : 1,
    
  add : function(a) {
    var f = v => v + this.base;
    return f(a);
  },

  addThruCall: function(a) {
    var f = v => v + this.base;
    var b = {
      base : 2
    };
            
    return f.call(b, a);
  }
};

console.log(adder.add(1));         // 輸出 2
console.log(adder.addThruCall(1)); // 仍然輸出 2（而不是3 ——譯者注）
           

不綁定 arguments

箭頭函數不會在其内部暴露出  

arguments

 對象： 

arguments.length

, 

arguments[0]

, 

arguments[1]

等等，都不會指向箭頭函數的 arguments，而是指向了箭頭函數所在作用域的一個名為 arguments 的值（如果有的話，否則，就是 undefined。——譯者注）。

var arguments = 42;
var arr = () => arguments;

arr(); // 42

function foo() {
  var f = () => arguments[0]; // foo's implicit arguments binding
  return f(2);
}

foo(1); // 1
           

箭頭函數沒有自己的 

arguments

 對象，不過在大多數情形下，rest參數可以給出一個解決方案：

function foo() { 
  var f = (...args) => args[0]; 
  return f(2); 
}

foo(1); // 2
           

像方法一樣使用箭頭函數

如上所述, 箭頭函數表達式對沒有方法名的函數是最合适的.讓我們看看當我們試着把它們作為方法時發生了什麼.

'use strict';
var obj = {
  i: 10,
  b: () => console.log(this.i, this),
  c: function() {
    console.log( this.i, this)
  }
}
obj.b(); // prints undefined, Window
obj.c(); // prints 10, Object {...}
           

箭頭函數沒有定義this綁定。 另一個涉及

Object.defineProperty()

:的示例：

'use strict';
var obj = {
  a: 10
};

Object.defineProperty(obj, "b", {
  get: () => {
    console.log(this.a, typeof this.a, this);
    return this.a+10; // represents global object 'Window', therefore 'this.a' returns 'undefined'
  }
});
           

使用 

new

 操作符

箭頭函數不能用作構造器，和 new 一起用就會抛出錯誤。

使用 

yield

 關鍵字

yield

 關鍵字通常不能在箭頭函數中使用（except when permitted within functions further nested within it）。是以，箭頭函數不能用作Generator函數。

傳回對象字面量EDIT

請牢記，用 

params => {object:literal} 

這種簡單的文法傳回一個對象字面量是行不通的：

var func = () => {  foo: 1  };
// Calling func() returns undefined!

var func = () => {  foo: function() {}  };
// SyntaxError: function statement requires a name
           

這是因為花括号（即 

{}

 ）裡面的代碼被解析為聲明序列了（例如， 

foo

 被認為是一個 label, 而非對象字面量裡的鍵）。

是以，記得用圓括号把對象字面量包起來：

var func = () => ({ foo: 1 });
           

換行

EDIT

箭頭函數在參數和箭頭之間不能換行哦

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

解析順序EDIT

在箭頭函數中的箭頭不是操作符(或者運算符,就像'+ -'那些), 但是 箭頭函數有特殊的解析規則就是:相比普通的函數, 随着操作符優先級不同互動也不同(建議看英文版)

let callback;

callback = callback || function() {}; // ok
callback = callback || () => {};      // SyntaxError: invalid arrow-function arguments
callback = callback || (() => {});    // ok
           

示例EDIT

// 一個空箭頭函數,傳回 undefined
let empty = () => {};

(() => "foobar")() // 傳回 "foobar" 

var simple = a => a > 15 ? 15 : a; 
simple(16); // 15
simple(10); // 10

let max = (a, b) => a > b ? a : b;

// Easy array filtering, mapping, ...

var arr = [5, 6, 13, 0, 1, 18, 23];
var sum = arr.reduce((a, b) => a + b);  // 66
var even = arr.filter(v => v % 2 == 0); // [6, 0, 18]
var double = arr.map(v => v * 2);       // [10, 12, 26, 0, 2, 36, 46]

         // 更多簡明的promise鍊
promise.then(a => {
  // ...
}).then(b => {
   // ...
});