js箭头函数

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

语法


基础语法

[javascript]  view plain  copy
  1. (param1, param2, …, paramN) => { statements }  
  2. (param1, param2, …, paramN) => expression  
  3.          // equivalent to:  => { return expression; }  
  4.   
  5. // 如果只有一个参数,圆括号是可选的:  
  6. (singleParam) => { statements }  
  7. singleParam => { statements }  
  8.   
  9. // 无参数的函数需要使用圆括号:  
  10. () => { statements }  

高级语法

[javascript]  view plain  copy
  1. // 返回对象字面量时应当用圆括号将其包起来:  
  2. params => ({foo: bar})  
  3.   
  4. // 支持 Rest parameters 和 default parameters:  
  5. (param1, param2, ...rest) => { statements }  
  6. (param1 = defaultValue1, param2, …, paramN = defaultValueN) => { statements }  
  7.   
  8. // Destructuring within the parameter list is also supported  
  9. var f = ([a, b] = [1, 2], {x: c} = {x: a + b}) => a + b + c;  
  10. f();  // 6  


描述


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

更短的函数

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

[javascript]  view plain  copy
  1. var a = [  
  2.   "Hydrogen",  
  3.   "Helium",  
  4.   "Lithium",  
  5.   "Beryl­lium"  
  6. ];  
  7.   
  8. var a2 = a.map(function(s){ return s.length });  
  9.   
  10. var a3 = a.map( s => s.length );  

不绑定 this

在箭头函数出现之前,每个新定义的函数都有其自己的this值(例如,构造函数的 this 指向了一个新的对象;严格模式下的函数的 this 值为 undefined;如果函数是作为对象的方法被调用的,则其 this 指向了那个调用它的对象)。在面向对象风格的编程中,这被证明是非常恼人的事情。

[javascript]  view plain  copy
  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.   
  11. var p = new Person();  

在 ECMAScript 3/5 中,这个问题可以通过新增一个变量来指向期望的 this 对象,然后将该变量放到闭包中来解决

[javascript]  view plain  copy
  1. function Person() {  
  2.   var self = this// 也有人选择使用 `that` 而非 `self`.   
  3.                    // 只要保证一致就好.  
  4.   self.age = 0;  
  5.   
  6.   setInterval(function growUp() {  
  7.     // 回调里面的 `self` 变量就指向了期望的那个对象了  
  8.     self.age++;  
  9.   }, 1000);  
  10. }  

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

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

[javascript]  view plain  copy
  1. function Person(){  
  2.   this.age = 0;  
  3.   
  4.   setInterval(() => {  
  5.     this.age++; // |this| 正确地指向了 person 对象  
  6.   }, 1000);  
  7. }  
  8.   
  9. var p = new Person();  


与 strict mode 的关系

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

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

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

使用 call 或 apply 调用

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

[javascript]  view plain  copy
  1. <span style="font-size:14px;">var adder = {  
  2.   base : 1,  
  3.       
  4.   add : function(a) {  
  5.     var f = v => v + this.base;  
  6.     return f(a);  
  7.   },  
  8.   
  9.   addThruCall: function(a) {  
  10.     var f = v => v + this.base;  
  11.     var b = {  
  12.       base : 2  
  13.     };  
  14.               
  15.     return f.call(b, a);  
  16.   }  
  17. };  
  18.   
  19. console.log(adder.add(1));         // 输出 2  
  20. console.log(adder.addThruCall(1)); // 仍然输出 2(而不是3 ——译者注)</span>  


不绑定 arguments

箭头函数不会在其内部暴露出arguments对象: arguments.lengtharguments[0]arguments[1] 等等,都不会指向箭头函数的 arguments,而是指向了箭头函数所在作用域的一个名为 arguments 的值(如果有的话,否则,就是 undefined)。

[javascript]  view plain  copy
  1. var arguments = 42;  
  2. var arr = () => arguments;  
  3.   
  4. arr(); // 42  
  5.   
  6. function foo() {  
  7.   var f = () => arguments[0]; // foo's implicit arguments binding  
  8.   return f(2);  
  9. }  
  10.   
  11. foo(1); // 1  

箭头函数没有自己的 arguments 对象,不过在大多数情形下,rest参数可以给出一个解决方案:

[javascript]  view plain  copy
  1. function foo() {   
  2.   var f = (...args) => args[0];   
  3.   return f(2);   
  4. }  
  5.   
  6. foo(1); // 2  


像方法一样使用箭头函数

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

[javascript]  view plain  copy
  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(); // prints undefined, Window  
  10. obj.c(); // prints 10, Object {...}  

箭头函数没有定义this绑定。

[javascript]  view plain  copy
  1. 'use strict';  
  2. var obj = {  
  3.   a: 10  
  4. };  
  5.   
  6. Object.defineProperty(obj, "b", {  
  7.   get: () => {  
  8.     console.log(this.a, typeof this.a, this);  
  9.     return this.a+10; // represents global object 'Window', therefore 'this.a' returns 'undefined'  
  10.   }  
  11. });  

使用new操作符

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

使用yield关键字

 yield关键字通常不能在箭头函数中使用(except when permitted within functions further nested within it)。因此,箭头函数不能用作Generator函数。

返回对象字面量

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

[javascript]  view plain  copy
  1. var func = () => {  foo: 1  };  
  2. // Calling func() returns undefined!  
  3.   
  4. var func = () => {  foo: function() {}  };  
  5. // SyntaxError: function statement requires a name  

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

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

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

换行

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

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

解析顺序

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

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

示例

[javascript]  view plain  copy
  1. // 一个空箭头函数,返回 undefined  
  2. let empty = () => {};  
  3.   
  4. (() => "foobar")() // 返回 "foobar"   
  5.   
  6. var simple = a => a > 15 ? 15 : a;   
  7. simple(16); // 15  
  8. simple(10); // 10  
  9.   
  10. let max = (a, b) => a > b ? a : b;  
  11.   
  12. // Easy array filtering, mapping, ...  
  13.   
  14. var arr = [5, 6, 13, 0, 1, 18, 23];  
  15. var sum = arr.reduce((a, b) => a + b);  // 66  
  16. var even = arr.filter(v => v % 2 == 0); // [6, 0, 18]  
  17. var double = arr.map(v => v * 2);       // [10, 12, 26, 0, 2, 36, 46]  
  18.   
  19. // 更多简明的promise链  
  20. promise.then(a => {  
  21.   // ...  
  22. }).then(b => {  
  23.    // ...  
  24. });  
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值