• 箭头函数


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

    更短的函数

    var materials = [
      'Hydrogen',
      'Helium',
      'Lithium',
      'Beryllium'
    ];
    
    materials.map(function(material) { 
      return material.length; 
    }); // [8, 6, 7, 9]
    
    materials.map((material) => {
      return material.length;
    }); // [8, 6, 7, 9]
    
    materials.map(material => material.length); // [8, 6, 7, 9]

    不绑定this

    在箭头函数出现之前,每个新定义的函数都有它自己的 this值(在构造函数的情况下是一个新对象,在严格模式的函数调用中为 undefined,如果该函数被作为“对象方法”调用则为基础对象等)。This被证明是令人厌烦的面向对象风格的编程。

    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值分配给封闭的变量,可以解决this问题。

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

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

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

    function Person(){
      this.age = 0;
    
      setInterval(() => {
        this.age++; // |this| 正确地指向person 对象
      }, 1000);
    }
    
    var p = new Person();

    与严格模式的关系

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

    function Person() {
      this.age = 0;
      var closure = "123"
      setInterval(function growUp() {
        this.age++;
        console.log(closure)
      }, 1000);
    }
    
    var p = new Person();
    
    function PersonX() {
      'use strict'
      this.age = 0;
      var closure = "123"
      setInterval(()=>{
        this.age++;
        console.log(closure)
      }, 1000);
    }
    
    var px = new PersonX();

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

    通过 call 或 apply 调用

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

    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只是引用了封闭作用域内的arguments:

    var arguments = [1, 2, 3];
    var arr = () => arguments[0];
    
    arr(); // 1
    
    function foo(n) {
      var f = () => arguments[0] + n; // 隐式绑定 foo 函数的 arguments 对象. arguments[0] 是 n
      return f();
    }
    
    foo(1); // 2

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

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

    像函数一样使用箭头函数

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

    'use strict';
    var obj = {
      i: 10,
      b: () => console.log(this.i, this),
      c: function() {
        console.log( this.i, this)
      }
    }
    obj.b(); 
    // undefined
    obj.c(); 
    // 10, Object {...}

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

    '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'
      }
    });

    使用 new 操作符

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

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

    使用prototype属性

    箭头函数没有prototype属性。

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

    使用 yield 关键字

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

    函数体

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

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

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

    返回对象字面量

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

    var func = () => { foo: 1 };               
    // Calling func() returns undefined!
    
    var func = () => { foo: function() {} };   
    // SyntaxError: function statement requires a name

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

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

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

    换行

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

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

    解析顺序

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

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

    更多示例

    // 空的箭头函数返回 undefined
    let empty = () => {};
    
    (() => 'foobar')(); 
    // Returns "foobar"
    // (这是一个立即执行函数表达式,可参阅 'IIFE'术语表) 
    
    
    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 => {
      // ...
    });
    
    // 无参数箭头函数在视觉上容易分析
    setTimeout( () => {
      console.log('I happen sooner');
      setTimeout( () => {
        // deeper code
        console.log('I happen later');
      }, 1);
    }, 1);

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

    var simple = a => a > 15 ? 15 : a;
    simple(16); // 15
    simple(10); // 10
    
    let max = (a, b) => a > b ? a : b;

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

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

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

    // 标准的闭包函数
    function A(){
          var i=0;
          return function b(){
                  return (++i);
          };
    };
    
    var v=A();
    v();    //1
    v();    //2
    
    
    //箭头函数体的闭包( i=0 是默认参数)
    var Add = (i=0) => {return (() => (++i) )};
    var v = Add();
    v();           //1
    v();           //2
    
    //因为仅有一个返回,return 及括号()也可以省略
    var Add = (i=0)=> ()=> (++i);

     箭头函数递归

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

    引用自:https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Functions/Arrow_functions
  • 相关阅读:
    网站压力测试工具----webbench
    skin.xml
    krpano和react的结合展示
    swiper的相关用法
    js的hover实现方法。
    js的slice和split和splice和substring和substr的区别
    使用JSSDK分享页面
    微信jssdk分享功能开发
    点击复制
    JS的document.all函数使用 示例
  • 原文地址:https://www.cnblogs.com/Yehudic/p/10139737.html
Copyright © 2020-2023  润新知