基本用法
- ES6 允许使用 “箭头”（
=>）定义函数。
let v = v => v
// 等同于
let f = function(f){
return f
}
- 如果箭头函数
不需要参数或需要多个参数，就使用一个圆括号代表参数部分。
let f = () => 5
// 等同于
let f = function() {
return 5 }
let sum = (num1, num2) => num1 + num2
// 等同于
let sum = function(num1, num2){
return num1 + num2
}
- 如果箭头函数的代码块部分
多于一条语句，就要使用大括号将它们括起来，并且使用return语句返回。
let sum = (num1, num2) => {
return num1 + num2 }
- 由于大括号被解释为代码块，所以如果箭头函数
直接返回一个对象，必须在对象外面加上括号，否则会报错。
let getTempItem = id => ({
id: id, name: 'Temp' })
- 下面是一种特殊情况，虽然可以运行，但会得到错误的结果。
let foo = () => {
a: 1 } // undefined
上面代码中，原始意图是返回一个对象{ a: 1 }，但是由于引擎认为大括号是代码块，所以执行了一行语句a: 1。这时，a可以被解释为语句的标签，因此实际执行的语句是1;，然后函数就结束了，没有返回值。
- 如果箭头函数
只有一行语句，且不需要返回值，可以采用下面的写法，就不用写大括号了。
let fn = () => void doesNotReturn()
- 箭头函数可以与变量解构结合使用。
const full = ({
fist, last}) => first + ' ' + last
//等同于
function full(person){
return person.first + ' ' + person.last
}
- 箭头函数使得表达更加简洁。
const isEven = n => n % 2 === 0
const square = n => n * n
上面代码只用了两行，就定义了两个简单的工具函数。如果不用箭头函数，可能就要占用多行，而且还不如现在这样写醒目。
- 箭头函数的一个用处是简化回调函数。
// 普通函数写法
[1,2,3].map(function (x) {
return x * x
})
// 箭头函数写法
[1,2,3].map ( x => x * x)
// 普通函数写法
let values = [2,5,8,6]
let result = values.sort(function (a, b){
return a - b
})
console.log(result) // 2,5,6,8
// 箭头函数写法
let values = [2,5,8,6]
let result = values.sort((a, b) => a - b)
console.log(result) // 2,5,6,8
使用注意点
- 箭头函数没有自己的 this 对象。
- 不可以当作构造函数，也就是说，不可以对箭头函数使用new命令，否则会抛出一个错误。
- 对于普通函数来说，内部的
this指向函数运行时所在的对象，但是这一点对箭头函数不成立。它没有自己的this对象，内部的this就是定义时上层作用域中的this。也就是说，箭头函数内部的this指向是固定的，相比之下，普通函数的this指向是可变的。
function foo(){
setTimeout(() => {
console.log('id:', this.id)
},100)
}
let id = 21
foo.call( {
id: 42 } ) // 42
上面代码中，
setTimeout()的参数是一个箭头函数，这个箭头函数的定义生效是在foo函数生成时，而它的真正执行要等到 100 毫秒后。如果是普通函数，执行时this应该指向全局对象window，这时应该输出21。但是，箭头函数导致this总是指向函数定义生效时所在的对象（本例是{id: 42}），所以打印出来的是42。
- 下面例子是回调函数分别为箭头函数和普通函数，对比它们内部的
this指向。
function Timer(){
this.s1 = 0
this.s2 = 0
// 箭头函数
setInterval(() => this.s1++, 1000)
// 普通函数
setInterval(function (){
this.s2++
}, 1000)
}
var timer = new Timer()
setTimeout(() => console.log('s1: ', timer.s1),3100) //s1: 3
setTimeout(() => console.log('s2: ', timer.s2),3100) //s2: 0
上面代码中，
Timer函数内部设置了两个定时器，分别使用了箭头函数和普通函数。前者的this绑定定义时所在的作用域（即Timer函数），后者的this指向运行时所在的作用域（即全局对象）。所以，3100 毫秒之后，timer.s1被更新了 3 次，而timer.s2一次都没更新。
- 箭头函数实际上可以让
this指向固定化，绑定this使得它不再可变，这种特性很有利于封装回调函数。下面是一个例子，DOM 事件的回调函数封装在一个对象里面。
let handler = {
id: '12345',
init: function() {
document.addEventListener('click',
event => this.doSomething(event.type),false)
},
doSomething: function(type) {
console.log('Handling ' + type + 'for ' + this.id)
}
}
handler.init() //Handling clickfor 12345
上面代码的
init()方法中，使用了箭头函数，这导致这个箭头函数里面的this，总是指向handler对象。如果回调函数是普通函数，那么运行this.doSomething()这一行会报错，因为此时this指向document对象。
总之，箭头函数根本没有自己的
this，导致内部的this就是外层代码块的this。正是因为它没有this，所以也就不能用作构造函数。
- Babel 转箭头函数产生的 ES5 代码，就能清楚地说明this的指向。
// ES6
function foo() {
setTimeout(() => {
console.log('id:', this.id);
}, 100);
}
// ES5
function foo() {
var _this = this;
setTimeout(function () {
console.log('id:', _this.id);
}, 100);
}
上面代码中，转换后的 ES5 版本清楚地说明了，箭头函数里面根本没有自己的this，而是引用外层的
this。
不适用场合
- 定义对象的方法，且该方法内部包括this。
const cat = {
lives: 9,
jumps: () => {
this.lives--
}
}
car.jumps() //报错 Missing initializer in const declaration
上面代码中，
cat.jumps()方法是一个箭头函数，这是错误的。调用cat.jumps()时，如果是普通函数，该方法内部的this指向cat；如果写成上面那样的箭头函数，使得this指向全局对象，因此不会得到预期结果。这是因为对象不构成单独的作用域，导致jumps箭头函数定义时的作用域就是全局作用域。
另一个例子：
var s = 21
const obj = {
s: 42,
m: () => console.log(this.s)
}
obj.m() //21
由于上面这个原因，对象的属性建议使用传统的写法定义，不要用箭头函数定义。
- 需要动态this的时候，也不应使用箭头函数。
var button = document.getElementById('press');
button.addEventListener('click', () => {
this.classList.toggle('on')
})
上面代码运行时，点击按钮会报错，因为
button的监听函数是一个箭头函数，导致里面的this就是全局对象。如果改成普通函数，this就会动态指向被点击的按钮对象。
不积跬步无以至千里 不积小流无以成江海