JS箭头函数

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

语法

基础语法

1
2
3
4
5
6
7
8
9
10
(param1, param2, …, paramN) => { statements }
(param1, param2, …, paramN) => expression
//相当于:(param1, param2, …, paramN) =>{ return expression; }

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

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

高级语法

1
2
3
4
5
6
7
8
9
10
11
//加括号的函数体返回对象字面量表达式:
params => ({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

描述

更短的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
var elements = [
'Hydrogen',
'Helium',
'Lithium',
'Beryllium'
];

elements.map(function(element) {
return element.length;
}); // 返回数组:[8, 6, 7, 9]

// 上面的普通函数可以改写成如下的箭头函数
elements.map((element) => {
return element.length;
}); // [8, 6, 7, 9]

// 当箭头函数只有一个参数时,可以省略参数的圆括号
elements.map(element => {
return element.length;
}); // [8, 6, 7, 9]

// 当箭头函数的函数体只有一个 `return` 语句时,可以省略 `return` 关键字和方法体的花括号
elements.map(element => element.length); // [8, 6, 7, 9]

// 在这个例子中,因为我们只需要 `length` 属性,所以可以使用参数解构
// 需要注意的是字符串 `"length"` 是我们想要获得的属性的名称,而 `lengthFooBArX` 则只是个变量名,
// 可以替换成任意合法的变量名
elements.map(({ "length": lengthFooBArX }) => lengthFooBArX); // [8, 6, 7, 9]

没有单独的this

在箭头函数出现之前,每一个新函数根据它是被如何调用的来定义这个函数的this值:

  • 如果该函数是一个构造函数,this指针指向一个新的对象
  • 在严格模式下的函数调用下,this指向undefined
  • 如果该函数是一个对象的方法,则它的this指针指向这个对象
  • 等等
1
2
3
4
5
6
7
8
9
10
11
12
function Person() {
// Person() 构造函数定义 `this`作为它自己的实例.
this.age = 0;

setInterval(function growUp() {
// 在非严格模式, growUp()函数定义 `this`作为全局对象,
// 与在 Person()构造函数中定义的 `this`并不相同.
this.age++;
}, 1000);
}

var p = new Person();

或者,可以创建绑定函数,以便将预先分配的this值传递到绑定的目标函数。

箭头函数不会创建自己的this,它只会从自己的作用域链的上一层继承this。因此,在下面的代码中,传递给setInterval的函数内的this与封闭函数中的this值相同:

1
2
3
4
5
6
7
8
9
function Person(){
this.age = 0;

setInterval(() => {
this.age++; // |this| 正确地指向 p 实例
}, 1000);
}

var p = new Person();

通过 callapply 调用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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

不绑定arguments

1
2
3
4
5
6
7
8
9
10
11
12
13
14
var arguments = [1, 2, 3];
var arr = () => arguments[0];

arr(); // 1

function foo(n) {
var f = () => arguments[0] + n; // 隐式绑定 foo 函数的 arguments 对象. arguments[0] 是 n,即传给foo函数的第一个参数
return f();
}

foo(1); // 2
foo(2); // 4
foo(3); // 6
foo(3,2);//6

在大多数情况下,使用剩余参数是相较使用arguments对象的更好选择。

1
2
3
4
5
6
7
8
9
10
11
function foo(arg) {
var f = (...args) => args[0];
return f(arg);
}
foo(1); // 1

function foo(arg1,arg2) {
var f = (...args) => args[1];
return f(arg1,arg2);
}
foo(1,2); //2

使用箭头函数作为方法

1
2
3
4
5
6
7
8
9
10
11
12
'use strict';
var obj = {
i: 10,
b: () => console.log(this.i, this),
c: function() {
console.log( this.i, this)
}
}
obj.b();
// undefined, Window{...}
obj.c();
// 10, Object {...}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
'use strict';
var obj = {
a: 10
};

Object.defineProperty(obj, "b", {
get: () => {
console.log(this.a, typeof this.a, this);
return this.a+10;
// 代表全局对象 'Window', 因此 'this.a' 返回 'undefined'
}
});

obj.b; // undefined "undefined" Window {postMessage: ƒ, blur: ƒ, focus: ƒ, close: ƒ, frames: Window, …}

使用 new 操作符

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

使用prototype属性

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

函数体

1
2
3
4
5
var func = x => x * x;
// 简写函数 省略return

var func = (x, y) => { return x + y; };
//常规编写 明确的返回值

函数体

记住用params => {object:literal}这种简单的语法返回对象字面量是行不通的。

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

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

这是因为花括号({} )里面的代码被解析为一系列语句(即 foo 被认为是一个标签,而非对象字面量的组成部分)。

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

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

换行

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

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

但是,可以通过在 ‘=>’ 之后换行,或者用 ‘( )’、’{ }’来实现换行,如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
var func = (a, b, c) =>
1;

var func = (a, b, c) => (
1
);

var func = (a, b, c) => {
return 1
};

var func = (
a,
b,
c
) => 1;

// 不会有语法错误

解析顺序

1
2
3
4
5
6
7
8
let callback;

callback = callback || function() {}; // ok

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

callback = callback || (() => {}); // ok