JS 箭头函数

🌙
手机阅读
本文目录结构

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

语法

基础语法

  1. (param1, param2, …, paramN) => { statements }
  2. (param1, param2, …, paramN) => expression
  3. // equivalent to: => { return expression; }
  4. // Parentheses are optional when there's only one parameter name:
  5. (singleParam) => { statements }
  6. singleParam => { statements }
  7. // The parameter list for a function with no parameters should be written with a pair of parentheses.
  8. () => { statements }

高级语法

  1. // Parenthesize the body of a function to return an object literal expression:
  2. params => ({foo: bar})
  3. // Rest parameters and default parameters are supported
  4. (param1, param2, ...rest) => { statements }
  5. (param1 = defaultValue1, param2, …, paramN = defaultValueN) => {
  6. statements }
  7. // Destructuring within the parameter list is also supported
  8. var f = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + c;
  9. f(); // 6

描述

参考 “ES6 In Depth: Arrow functions” on hacks.mozilla.org.

引入箭头函数有两个方面的作用:更简短的函数并且不绑定 this。

更短的函数

  1. var elements = [
  2. 'Hydrogen',
  3. 'Helium',
  4. 'Lithium',
  5. 'Beryllium'
  6. ];
  7. elements.map(function(element) {
  8. return element.length;
  9. }); // 返回数组:[8, 6, 7, 9]
  10. // 上面的普通函数可以改写成如下的箭头函数
  11. elements.map((element) => {
  12. return element.length;
  13. }); // [8, 6, 7, 9]
  14. // 当箭头函数只有一个参数时,可以省略参数的圆括号
  15. elements.map(element => {
  16. return element.length;
  17. }); // [8, 6, 7, 9]
  18. // 当箭头函数的函数体只有一个 `return` 语句时,可以省略 `return` 关键字和方法体的花括号
  19. elements.map(element => element.length); // [8, 6, 7, 9]
  20. // 在这个例子中,因为我们只需要 `length` 属性,所以可以使用参数解构
  21. // 需要注意的是字符串 `"length"` 是我们想要获得的属性的名称,而 `lengthFooBArX` 则只是个变量名,
  22. // 可以替换成任意合法的变量名
  23. elements.map(({ "length": lengthFooBArX }) => lengthFooBArX); // [8, 6, 7, 9]

不绑定 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();

在 ECMAScript 3/5 中,通过将 this 值分配给封闭的变量,可以解决 this 问题。

  1. function Person() {
  2. var that = this;
  3. that.age = 0;
  4. setInterval(function growUp() {
  5. // 回调引用的是`that`变量, 其值是预期的对象.
  6. that.age++;
  7. }, 1000);
  8. }

或者,可以创建绑定函数,以便将预先分配的 this 值传递到绑定的目标函数(上述示例中的 growUp() 函数)。

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

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

与严格模式的关系 鉴于 this 是词法层面上的,严格模式中与 this 相关的规则都将被忽略。

  1. function Person() {
  2. this.age = 0;
  3. var closure = "123"
  4. setInterval(function growUp() {
  5. this.age++;
  6. console.log(closure)
  7. }, 1000);
  8. }
  9. var p = new Person();
  10. function PersonX() {
  11. 'use strict'
  12. this.age = 0;
  13. var closure = "123"
  14. setInterval(()=>{
  15. this.age++;
  16. console.log(closure)
  17. }, 1000);
  18. }
  19. var px = new PersonX();

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

通过 call 或 apply 调用

由于 箭头函数没有自己的 this 指针,通过 call() 或 apply() 方法调用一个函数时,只能传递参数(不能绑定 this— 译者注),他们的第一个参数会被忽略。(这种现象对于 bind 方法同样成立 — 译者注)

  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

箭头函数不绑定 Arguments 对象。因此,在本示例中,arguments 只是引用了封闭作用域内的 arguments:

  1. var arguments = [1, 2, 3];
  2. var arr = () => arguments[0];
  3. arr(); // 1
  4. function foo(n) {
  5. var f = () => arguments[0] + n; // 隐式绑定 foo 函数的 arguments 对象. arguments[0] 是 n,即传给foo函数的第一个参数
  6. return f();
  7. }
  8. foo(1); // 2
  9. foo(2); // 4
  10. foo(3); // 6
  11. foo(3,2);//6

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

  1. function foo(arg) {
  2. var f = (...args) => args[0];
  3. return f(arg);
  4. }
  5. foo(1); // 1
  6. function foo(arg1,arg2) {
  7. var f = (...args) => args[1];
  8. return f(arg1,arg2);
  9. }
  10. foo(1,2); //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();
  10. // undefined, Window{...}
  11. obj.c();
  12. // 10, Object {...}

箭头函数没有定义 this 绑定。另一个涉及 Object.defineProperty() 的示例:

  1. 'use strict';
  2. var obj = {
  3. a: 10
  4. };
  5. Object.defineProperty(obj, "b", {
  6. get: () => {
  7. console.log(this.a, typeof this.a, this);
  8. return this.a+10;
  9. // 代表全局对象 'Window', 因此 'this.a' 返回 'undefined'
  10. }
  11. });
  12. obj.b; // undefined "undefined" Window {postMessage: ƒ, blur: ƒ, focus: ƒ, close: ƒ, frames: Window, …}

使用 new 操作符

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

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

使用 prototype 属性

箭头函数没有 prototype 属性。

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

使用 yield 关键字

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

函数体

箭头函数可以有一个“简写体”或常见的“块体”。

在一个简写体中,只需要一个表达式,并附加一个隐式的返回值。在块体中,必须使用明确的 return 语句。

  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. // Calling func() returns undefined!
  3. var func = () => { foo: function() {} };
  4. // SyntaxError: function statement requires a name

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

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

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

换行

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

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

解析顺序

虽然箭头函数中的箭头不是运算符,但箭头函数具有与常规函数不同的特殊运算符优先级解析规则。

  1. let callback;
  2. callback = callback || function() {}; // ok
  3. callback = callback || () => {};
  4. // SyntaxError: invalid arrow-function arguments
  5. callback = callback || (() => {}); // ok

更多示例

  1. // 空的箭头函数返回 undefined
  2. let empty = () => {};
  3. (() => 'foobar')();
  4. // Returns "foobar"
  5. // (这是一个立即执行函数表达式,可参阅 'IIFE'术语表)
  6. var simple = a => a > 15 ? 15 : a;
  7. simple(16); // 15
  8. simple(10); // 10
  9. let max = (a, b) => a > b ? a : b;
  10. // Easy array filtering, mapping, ...
  11. var arr = [5, 6, 13, 0, 1, 18, 23];
  12. var sum = arr.reduce((a, b) => a + b);
  13. // 66
  14. var even = arr.filter(v => v % 2 == 0);
  15. // [6, 0, 18]
  16. var double = arr.map(v => v * 2);
  17. // [10, 12, 26, 0, 2, 36, 46]
  18. // 更简明的promise链
  19. promise.then(a => {
  20. // ...
  21. }).then(b => {
  22. // ...
  23. });
  24. // 无参数箭头函数在视觉上容易分析
  25. setTimeout( () => {
  26. console.log('I happen sooner');
  27. setTimeout( () => {
  28. // deeper code
  29. console.log('I happen later');
  30. }, 1);
  31. }, 1);

箭头函数也可以使用条件(三元)运算符:

  1. var simple = a => a > 15 ? 15 : a;
  2. simple(16); // 15
  3. simple(10); // 10
  4. let max = (a, b) => a > b ? a : b;

箭头函数内定义的变量及其作用域

  1. // 常规写法
  2. var greeting = () => {let now = new Date(); return ("Good" + ((now.getHours() > 17) ? " evening." : " day."));}
  3. greeting(); //"Good day."
  4. console.log(now); // ReferenceError: now is not defined 标准的let作用域
  5. // 参数括号内定义的变量是局部变量(默认参数)
  6. var greeting = (now=new Date()) => "Good" + (now.getHours() > 17 ? " evening." : " day.");
  7. greeting(); //"Good day."
  8. console.log(now); // ReferenceError: now is not defined
  9. // 对比:函数体内{}不使用var定义的变量是全局变量
  10. var greeting = () => {now = new Date(); return ("Good" + ((now.getHours() > 17) ? " evening." : " day."));}
  11. greeting(); //"Good day."
  12. console.log(now); // Fri Dec 22 2017 10:01:00 GMT+0800 (中国标准时间)
  13. // 对比:函数体内{} 用var定义的变量是局部变量
  14. var greeting = () => {var now = new Date(); return ("Good" + ((now.getHours() > 17) ? " evening." : " day."));}
  15. greeting(); //"Good day."
  16. console.log(now); // ReferenceError: now is not defined

箭头函数也可以使用闭包:

  1. // 标准的闭包函数
  2. function A(){
  3. var i=0;
  4. return function b(){
  5. return (++i);
  6. };
  7. };
  8. var v=A();
  9. v(); //1
  10. v(); //2
  11. //箭头函数体的闭包( i=0 是默认参数)
  12. var Add = (i=0) => {return (() => (++i) )};
  13. var v = Add();
  14. v(); //1
  15. v(); //2
  16. //因为仅有一个返回,return 及括号()也可以省略
  17. var Add = (i=0)=> ()=> (++i);

箭头函数递归

  1. var fact = (x) => ( x==0 ? 1 : x*fact(x-1) );
  2. fact(5); // 120

AXIHE / 精选资源

浏览全部教程

面试题

学习网站

前端培训
自己甄别

前端书籍

关于朱安邦

我叫 朱安邦,阿西河的站长,在杭州。

以前是一名平面设计师,后来开始接接触前端开发,主要研究前端技术中的JS方向。

业余时间我喜欢分享和交流自己的技术,欢迎大家关注我的 Bilibili

关注我: Github / 知乎

于2021年离开前端领域,目前重心放在研究区块链上面了

我叫朱安邦,阿西河的站长

目前在杭州从事区块链周边的开发工作,机械专业,以前从事平面设计工作。

2014年底脱产在老家自学6个月的前端技术,自学期间几乎从未出过家门,最终找到了满意的前端工作。更多>

于2021年离开前端领域,目前从事区块链方面工作了