深入理解JavaScript中的箭头函数

深入理解JavaScript箭头函数
http://blog.youkuaiyun.com/zls986992484/article/details/53838497

箭头函数就是个简写形式的函数表达式，并且它拥有词法作用域的this值（即不会新产生自己作用域下的this，arguments,super和new.target等对象）。此外，箭头函数总是匿名的。
语法

基础语法
[javascript] view plain copy
(param1, param2, …, paramN) => { statements }
(param1, param2, …, paramN) => expression
// equivalent to: => { return expression; }

// 如果只有一个参数，圆括号是可选的:
(singleParam) => { statements }
singleParam => { statements }

// 无参数的函数需要使用圆括号:
() => { statements }
高级语法
[javascript] view plain copy
// 返回对象字面量时应当用圆括号将其包起来:
params => ({foo: bar})

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

// Destructuring within the parameter list is also supported
var f = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + c;
f(); // 6

描述

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

在一些函数式编程模式里，更短的函数书写方式很受欢迎。试比较：

[javascript] view plain copy
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 指向了那个调用它的对象）。在面向对象风格的编程中，这被证明是非常恼人的事情。

[javascript] view plain copy
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 对象，然后将该变量放到闭包中来解决。
[javascript] view plain copy
function Person() {
var self = this; // 也有人选择使用 that 而非 self.
// 只要保证一致就好.
self.age = 0;

setInterval(function growUp() {
// 回调里面的 self 变量就指向了期望的那个对象了
self.age++;
}, 1000);
}

除此之外，还可以使用bind函数，把期望的 this 值传递给 growUp() 函数。

箭头函数则会捕获其所在上下文的 this 值，作为自己的 this 值，因此下面的代码将如期运行。

[javascript] view plain copy
function Person(){
this.age = 0;

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

var p = new Person();

与 strict mode 的关系

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

[javascript] view plain copy
var f = () => {‘use strict’; return this};
f() === window; // 或全局对象

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

使用 call 或 apply 调用

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

[javascript] view plain copy
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)。

[javascript] view plain copy
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参数可以给出一个解决方案：
[javascript] view plain copy
function foo() {
var f = (…args) => args[0];
return f(2);
}

foo(1); // 2

像方法一样使用箭头函数

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

[javascript] view plain copy
‘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绑定。

[javascript] view plain copy
‘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函数。

返回对象字面量

请牢记，用 params => {object:literal} 这种简单的语法返回一个对象字面量是行不通的：

[javascript] view plain copy
var func = () => { foo: 1 };
// Calling func() returns undefined!

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

这是因为花括号（即 {} ）里面的代码被解析为声明序列了（例如， foo 被认为是一个 label, 而非对象字面量里的键）。

所以，记得用圆括号把对象字面量包起来：

[javascript] view plain copy
var func = () => ({ foo: 1 });
换行

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

[javascript] view plain copy
var func = ()
=> 1; // SyntaxError: expected expression, got ‘=>’

解析顺序
在箭头函数中的箭头不是操作符(或者运算符,就像’+ -‘那些), 但是 箭头函数有特殊的解析规则就是:相比普通的函数, 随着操作符优先级不同交互也不同(建议看英文版)。

[javascript] view plain copy
let callback;

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

示例
[javascript] view plain copy
// 一个空箭头函数,返回 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 => {
// …
});

深入理解JavaScript中的箭头函数
http://www.jb51.net/article/70142.htm
从一开始箭头就是 JavaScript 的一部分，在第一个 JavaScript 中就建议将内联的脚本代码包裹在 HTML 的注释中，这可以防止那些不支持 JavaScript 的浏览器错误滴将你的代码显示为明文。你也许写过下面这样的代码：
?
1
2
3
4
5
6
7
8
9
10
11

古老的浏览器将看到两个不被支持的标签和一段注释，只有支持 JavaScript 的新浏览器才会将其解析为 JavaScript 代码。
为了支持这个古怪的特性，浏览器的 JavaScript 引擎把 也表示一个单行注释，与 HTML 不同的是，在 HTML 中，–> 之前的部分是注释内容，而在 JavaScript 中，在 –> 之后的行才是注释。
只有当 –> 出现在一行的开始时，才表示该箭头是一个注释，因为在其他情况下，–> 是一个操作符（goes to）。
?
1
2
3
4
5
6
7
8
9
10
11
function countdown(n) {
while (n–>0) // “n goes to zero”
alert(n);
blastoff();
}

function countdown(n) {
while (n–>0) // “n goes to zero”
alert(n);
blastoff();
}
上面代码是真实能运行的。循环运行直到 n 为 0，这并不是 ES6 的新特性，但结合我们熟悉的特性，这具有很强的误导性。你能搞明白上面代码的运行情况吗？你可以在 Stack Overflow 上找到相应的解答。
当然还有一个箭头，那就是小于等于操作符 <=，也许你还可以找到使用箭头的地方，但我们还是停下来，看一个我们从没见过的箭头：
goes to 操作符
<= 小于等于操作符
=> ???
那么，=> 表示什么呢？这就是本文将讨论的话题。
首先，我们来谈谈函数。
无处不在的函数表达式
JavaScript 一个有趣的特点是，任何时候你需要一个函数，你可以很方便地创建它们。
例如，为一个按钮绑定点击事件：
?
1
2
3
$(“#confetti-btn”).click(

$(“#confetti-btn”).click( jQuery 的 .click() 方法需要一个函数作为参数，我们可以很方便地就地创建一个函数： ? 1 2 3 4 5 6 7 8 9 10$(“#confetti-btn”).click(function (event) {
playTrumpet();
fireConfettiCannon();
});

$(“#confetti-btn”).click(function (event) {
playTrumpet();
fireConfettiCannon();
});
现在对我们来说，编写这样的代码是最自然的事了。但是在 JavaScript 流行起来之前，这种风格的代码看起来还是有些奇怪，因为在其他语言中都没有这样的特性。在 1958 年，Lisp 就有了函数表达式，也叫 lambda 函数，而在存在多年的 C++、Python、C# 和 Java 中没有该特性。
现在，这四门语言都有了 lambda 表达式，而且新出现的语言都普遍内置了 lambda 表达式。如今 JavaScript 也支持该特性了，这必须感谢那些重度依赖 lambda 表达式的库的开发者，这推动了该特性被广泛采纳。
与其他几门语言相比，JavaScript 的语法略显冗长：
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// A very simple function in six languages.
function (a) { return a > 0; } // JS
[](int a) { return a > 0; } // C++
(lambda (a) (> a 0)) ;; Lisp
lambda a: a > 0 # Python
a => a > 0 // C#
a -> a > 0 // Java

// A very simple function in six languages.
function (a) { return a > 0; } // JS
[](int a) { return a > 0; } // C++
(lambda (a) (> a 0)) ;; Lisp
lambda a: a > 0 # Python
a => a > 0 // C#
a -> a > 0 // Java
箭头函数
ES6 引入了一种新的语法来编写函数：
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// ES5
var selected = allJobs.filter(function (job) {
return job.isSelected();
});

// ES6
var selected = allJobs.filter(job => job.isSelected());

// ES5
var selected = allJobs.filter(function (job) {
return job.isSelected();
});

// ES6
var selected = allJobs.filter(job => job.isSelected());
当你需要只有一个参数的函数，箭头函数的语法可以简化为 Identifier => Expression，直接省略了 function 和 return 关键字，连括号和结尾的分号也同时省略了。
编写一个有多个（或没有参数，或 Rest 参数和参数默认值，或解构参数）参数的函数，你需要用括号将参数括起来：
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// ES5
var total = values.reduce(function (a, b) {
return a + b;
}, 0);

// ES6
var total = values.reduce((a, b) => a + b, 0);

// ES5
var total = values.reduce(function (a, b) {
return a + b;
}, 0);

// ES6
var total = values.reduce((a, b) => a + b, 0);
箭头函数还可以与一些工具函数库完美地配合使用，比如 Underscore.js 和 Immutable，事实上，Immutable 文档中的例子全部都是使用 ES6 编写，其中有很多已经使用到了箭头函数。
函数体除了使用一个表达式外，箭头函数还可以包含一个语句块，回忆之前我们提到过的例子：
?
1
2
3
4
5
6
7
8
9
10
11
// ES5
$(“#confetti-btn”).click(function (event) {
playTrumpet();
fireConfettiCannon();
});

// ES5
$(“#confetti-btn”).click(function (event) { playTrumpet(); fireConfettiCannon(); }); 下面是采用箭头函数的写法： ? 1 2 3 4 5 6 7 8 9 10 11 // ES6$(“#confetti-btn”).click(event => {
playTrumpet();
fireConfettiCannon();
});

// ES6
$(“#confetti-btn”).click(event => {
playTrumpet();
fireConfettiCannon();
});
需要注意的是，使用语句块的箭头函数不会自动返回一个值，必须显式地使用 return 来返回一个值。
还有一个忠告，当使用箭头函数来返回一个对象时，始终使用括号将返回的对象括起来：
?
1
2
3
4
5
6
7
8
// create a new empty object for each puppy to play with
var chewToys = puppies.map(puppy => {}); // BUG!
var chewToys = puppies.map(puppy => ({})); // ok

// create a new empty object for each puppy to play with
var chewToys = puppies.map(puppy => {}); // BUG!
var chewToys = puppies.map(puppy => ({})); // ok
因为空对象 {} 与空语句块 {} 看上去一模一样，ES6 将始终把紧跟在 => 后面的 { 当作语句块的开始，而不是一个对象的开始，那么 puppy => {} 就被解析为一个没有函数体的箭头函数，而且返回值为 undefined