精华内容
下载资源
问答
  • 箭头函数和普通函数
    2022-06-08 14:24:38

    js的箭头函数和普通函数的区别

    最近室友面试,又问到了这个问题,索性自己也整理整理,希望看到的大佬们也帮忙补充补充,感谢感谢!

    箭头函数

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

        function Person1() {
          this.age = 0
          setTimeout(() => {
            console.log(this.age) 
            // |this| 正确地指向 p1 实例  所以打印为0
          }, 1000)
        }
        var p1 = new Person1()
        /*
          箭头函数不会创建自己的 this,它只会从自己的作用域链的上一层继承 this
          因此,在上面的代码中,传递给 setTimeout 的函数内的this与封闭函数中的this值相同
        */
    
        function Person2() {
          this.age = 0
          setTimeout(function () {
            console.log(this.age) 
            // |this| 指向 window  所以打印为undefined
          }, 1000)
        }
        var p2 = new Person2()
        /*
          在非严格模式,setTimeout() 函数定义 `this`作为全局对象,
          与在 Person2() 构造函数中定义的 `this`并不相同
        */
    
        function Person3() {
          let that = this
          this.age = 0
          setTimeout(function () {
            // 回调引用的是`that`变量,其值是预期的对象。正确地指向 p3 实例  所以打印为0
            console.log(that.age)
          }, 1000)
        }
        var p3 = new Person3()
        /*
          通过将 this 值分配给封闭的变量,可以解决 this 问题。
        */
    
    
    

    注意点:
    1、箭头函数不能用作构造器,和 new一起用会抛出错误。
    2、箭头函数没有prototype属性。
    3、 yield 关键字通常不能在箭头函数中使用(除非是嵌套在允许使用的函数内)。因此,箭头函数不能用作函数生成器。

    普通函数

    说到普通函数,普通函数的实际参数会被保存在一个类似数组的 arguments 对象中。

    arguments[i]
    

    其中i是参数的序数编号(译注:数组索引),以 0 开始。所以第一个传来的参数会是arguments[0]。参数的数量由arguments.length表示。

    使用 arguments 对象,可以处理比声明的更多的参数来调用函数。这在你事先不知道会需要将多少参数传递给函数时十分有用。

    你可以用arguments.length来获得实际传递给函数的参数的数量,然后用arguments对象来取得每个参数。

    备注:arguments变量只是 ”类数组对象“,并不是一个数组。称其为类数组对象是说它有一个索引编号和length属性。尽管如此,它并不拥有全部的 Array 对象的操作方法。

     function func() {
        console.log(arguments)
        // Arguments(3) [1, 2, 3, callee: ƒ, Symbol(Symbol.iterator): ƒ]
     }
     func(1, 2, 3)
    

    this指向不同:
    1、普通函数,谁调用this ,this就指向谁;
    2、箭头函数,在哪里定义函数, this就指向谁(可以理解为,内部的箭头函数不会改变this指向对象的,this仍然指向外面函数的作用域)

    补充:
    箭头函数内的this指向上层对象,bind()、call()、apply()均无法改变指向。
    普通函数内的this执行调用其函数的对象。

    可以说普通函数的this指向是不固定的;

        let obj = {
          a: 10,
          f1: () => {
            console.log(this, this.a)
          },
          f2: function () {
            console.log(this, this.a)
          }
        }
        
        obj.f1() // Window   undefined
        obj.f2() // {a: 10, f1: ƒ, f2: ƒ}    10
    

    两者区别

    1、箭头函数表达式的语法比函数表达式更简洁;

    2、 箭头函数不会创建自己的this,所以它没有自己的this,它只会从自己的作用域链的上一层继承this;

    3、箭头函数继承而来的this指向永远不变,是继承的它定义时所处的全局执行环境, 之后不再改变;

    4、箭头函数继承而来的this指向永远不变,call()、apply()、bind()无法改变箭头函数中this的指向;

    5、箭头函数不能作为构造函数使用,不能使用new关键字;

    6、箭头函数没有自己的arguments,可以使用拓展运算符代替;

    7、箭头函数没有原型prototype,prototype是普通函数用于获取原型对象的;

    8、箭头函数不能用作Generator函数,不能使用yeild关键字;

    更多相关内容
  • 普通函数和箭头函数的区别: 箭头函数的this指向规则: 1. 箭头函数没有prototype(原型),所以箭头函数本身没有this let a = () =>{}; console.log(a.prototype); // undefined 2. 箭头函数的this指向在定义...

    箭头函数是ES6的API,相信很多人都知道,因为其语法上相对于普通函数更简洁,深受大家的喜爱。就是这种我们日常开发中一直在使用的API,大部分同学却对它的了解程度还是不够深...

    普通函数和箭头函数的区别:

    箭头函数的this指向规则:

    1. 箭头函数没有prototype(原型),所以箭头函数本身没有this

    let a = () =>{};
    console.log(a.prototype); // undefined

    2. 箭头函数的this指向在定义的时候继承自外层第一个普通函数的this。

    下面栗子中在一个函数中定义箭头函数,然后在另一个函数中执行箭头函数。

    let a,
      barObj = { msg: 'bar的this指向' };
    fooObj = { msg: 'foo的this指向' };
    bar.call(barObj); // 将bar的this指向barObj
    foo.call(fooObj); // 将foo的this指向fooObj
    function foo() {
      a(); // 结果:{ msg: 'bar的this指向' }
    }
    function bar() {
      a = () => {
        console.log(this, 'this指向定义的时候外层第一个普通函数'); // 
      }; // 在bar中定义 this继承于bar函数的this指向
    }

    从上面栗子中可以得出两点

    1. 箭头函数的this指向定义时所在的外层第一个普通函数,跟使用位置没有关系
    2. 被继承的普通函数的this指向改变,箭头函数的this指向会跟着改变

    3. 不能直接修改箭头函数的this指向

    上个栗子中的foo函数修改一下,尝试直接修改箭头函数的this指向。

    let fnObj = { msg: '尝试直接修改箭头函数的this指向' };
    function foo() {
      a.call(fnObj); // 结果:{ msg: 'bar的this指向' }
    }

    很明显,call显示绑定this指向失败了,包括aaply、bind都一样。

    它们(call、aaply、bind)会默认忽略第一个参数,但是可以正常传参。

    然后我又通过隐式绑定来尝试同样也失败了,new 调用会报错,这个稍后再说。

    SO,箭头函数不能直接修改它的this指向

    幸运的是,我们可以通过间接的形式来修改箭头函数的指向:

    去修改被继承的普通函数的this指向,然后箭头函数的this指向也会跟着改变,这在上一个栗子中有演示。

    bar.call(barObj); // 将bar普通函数的this指向barObj 然后内部的箭头函数也会指向barObj

    4. 箭头函数外层没有普通函数,严格模式和非严格模式下它的this都会指向window(全局对象)

    唔,这个问题实际上是面试官提出来的,当时我认为的箭头函数规则就是:箭头函数的this指向继承自外层第一个普通函数的this,现在看来真是不严谨(少说一个定义的时候),要是面试官问我:定义和执行不在同一个普通函数中,它又指向哪里,肯定歇菜...

    既然箭头函数的this指向在定义的时候继承自外层第一个普通函数的this,那么:

    当箭头函数外层没有普通函数,它的this会指向哪里

    这里跟我之前写的this绑定规则不太一样(不懂的可以点进去看一下),普通函数的默认绑定规则是:

    在非严格模式下,默认绑定的this指向全局对象,严格模式下this指向undefined

    如果箭头函数外层没有普通函数继承,它this指向的规则

    经过测试,箭头函数在全局作用域下,严格模式和非严格模式下它的this都会指向window(全局对象)

    Tip:测试的时候发现严格模式在中途声明无效,必须在全局/函数的开头声明才会生效

    a = 1;
    'use strict'; // 严格模式无效 必须在一开始就声明严格模式
    b = 2; // 不报错

    箭头函数的

    箭头函数的arguments

    箭头函数的this指向全局,使用arguments会报未声明的错误

    如果箭头函数的this指向window(全局对象)使用arguments会报错,未声明arguments

    let b = () => {
      console.log(arguments);
    };
    b(1, 2, 3, 4); // Uncaught ReferenceError: arguments is not defined

    PS:如果你声明了一个全局变量为arguments,那就不会报错了,但是你为什么要这么做呢?

    箭头函数的this指向普通函数时,它的argumens继承于该普通函数

    上面是第一种情况:箭头函数的this指向全局对象,会报arguments未声明的错误。

    第二种情况是:箭头函数的this如果指向普通函数,它的argumens继承于该普通函数。

    function bar() {
      console.log(arguments); // ['外层第二个普通函数的参数']
      bb('外层第一个普通函数的参数');
      function bb() {
        console.log(arguments); // ["外层第一个普通函数的参数"]
        let a = () => {
          console.log(arguments, 'arguments继承this指向的那个普通函数'); // ["外层第一个普通函数的参数"]
        };
        a('箭头函数的参数'); // this指向bb
      }
    }
    bar('外层第二个普通函数的参数');

    那么应该如何来获取箭头函数不定数量的参数呢?答案是:ES6的rest参数(...扩展符)

    rest参数获取函数的多余参数

    这是ES6的API,用于获取函数不定数量的参数数组,这个API是用来替代arguments的,API用法如下:

    let a = (first, ...abc) => {
      console.log(first, abc); // 1 [2, 3, 4]
    };
    a(1, 2, 3, 4);

    上面的栗子展示了,获取函数除第一个确定的参数,以及用一个变量接收其他剩余参数的示例。

    也可以直接接收函数的所有参数,rest参数的用法相对于arguments的优点:

    1. 箭头函数和普通函数都可以使用。

    2. 更加灵活,接收参数的数量完全自定义。

    3. 可读性更好

      参数都是在函数括号中定义的,不会突然出现一个arguments,以前刚见到的时候,真的好奇怪了!

    4. rest是一个真正的数组,可以使用数组的API。

      因为arguments是一个类数组的对象,有些人以为它是真正的数组,所以会出现以下场景:

      arguments.push(0); // arguments.push is not a function

      如上,如果我们需要使用数组的API,需要使用扩展符/Array.from来将它转换成真正的数组:

      arguments = [...arguments]; 或者 :arguments = Array.from(arguments);

    rest参数有两点需要注意

    1. rest必须是函数的最后一位参数:

      let a = (first, ...rest, three) => {
        console.log(first, rest,three); // 报错:Rest parameter must be last formal parameter
      };
      a(1, 2, 3, 4);
    2. 函数的length属性,不包括 rest 参数

      (function(...a) {}).length  // 0
      (function(a, ...b) {}).length  // 1

    扩展运算符还可以用于数组

    PS:感觉这里写多了,但比较喜欢把一个知识点讲清楚...

    使用new调用箭头函数会报错

    无论箭头函数的thsi指向哪里,使用new调用箭头函数都会报错,因为箭头函数没有constructor

    let a = () => {};
    let b = new  a(); // a is not a constructor

    箭头函数不支持new.target

    new.target是ES6新引入的属性,普通函数如果通过new调用,new.target会返回该函数的引用。

    此属性主要:用于确定构造函数是否为new调用的。

    1. 箭头函数的this指向全局对象,在箭头函数中使用箭头函数会报错

      let a = () => {
        console.log(new.target); // 报错:new.target 不允许在这里使用
      };
      a();
    2. 箭头函数的this指向普通函数,它的new.target就是指向该普通函数的引用。

      new bb();
      function bb() {
        let a = () => {
          console.log(new.target); // 指向函数bb:function bb(){...}
        };
        a();
      }

    更多关于new.target可以看一下阮一峰老师关于这部分的解释

    箭头函数不支持重命名函数参数,普通函数的函数参数支持重命名

    如下示例,普通函数的函数参数支持重命名,后面出现的会覆盖前面的,箭头函数会抛出错误:

    function func1(a, a) {
      console.log(a, arguments); // 2 [1,2]
    }
    
    var func2 = (a,a) => {
      console.log(a); // 报错:在此上下文中不允许重复参数名称
    };
    func1(1, 2); func2(1, 2);

    箭头函数相对于普通函数语法更简洁优雅:

    讲道理,语法上的不同,也属与它们两个的区别!

    1. 箭头函数都是匿名函数,并且都不用写function

    2. 只有一个参数的时候可以省略括号:

      var f = a => a; // 传入a 返回a
    3. 函数只有一条语句时可以省略{}return

      var f = (a,b,c) => a; // 传入a,b,c 返回a
    4. 简化回调函数,让你的回调函数更优雅:

    [1,2,3].map(function (x) {
      return x * x;
    }); // 普通函数写法 
    [1,2,3].map(x => x * x); // 箭头函数只需要一行

    箭头函数的注意事项及不适用场景

    箭头函数的注意事项

    1. 一条语句返回对象字面量,需要加括号,或者直接写成多条语句的return形式,

      否则像func中演示的一样,花括号会被解析为多条语句的花括号,不能正确解析

    var func1 = () => { foo: 1 }; // 想返回一个对象,花括号被当成多条语句来解析,执行后返回undefined
    var func2 = () => ({foo: 1}); // 用圆括号是正确的写法
    var func2 = () => {
      return {
        foo: 1 // 更推荐直接当成多条语句的形式来写,可读性高
      };
    };
    1. 箭头函数在参数和箭头之间不能换行!
    var func = ()
               => 1;  // 报错: Unexpected token =>
    1. 箭头函数的解析顺序相对靠前

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

    let a = false || function() {}; // ok
    let b = false || () => {}; // Malformed arrow function parameter list
    let c = false || (() => {}); // ok

    箭头函数不适用场景:

    围绕两点:箭头函数的this意外指向和代码的可读性。

    1. 定义字面量方法,this的意外指向。

    因为箭头函数的简洁

    const obj = {
      array: [1, 2, 3],
      sum: () => {
        // 根据上文学到的:外层没有普通函数this会指向全局对象
        return this.array.push('全局对象下没有array,这里会报错'); // 找不到push方法
      }
    };
    obj.sum();

    上述栗子使用普通函数或者ES6中的方法简写的来定义方法,就没有问题了:

    // 这两种写法是等价的
    sum() {
      return this.array.push('this指向obj');
    }
    sum: function() {
      return this.array.push('this指向obj');
    }

    还有一种情况是给普通函数的原型定义方法的时候,通常会在普通函数的外部进行定义,比如说继承/添加方法的时候。

    这时候因为没有在普通函数的内部进行定义,所以this会指向其他普通函数,或者全局对象上,导致bug!

    1. 回调函数的动态this

    下文是一个修改dom文本的操作,因为this指向错误,导致修改失败:

    const button = document.getElementById('myButton');
    button.addEventListener('click', () => {
        this.innerHTML = 'Clicked button'; // this又指向了全局
    });

    你也知道了,改成普通函数就成了。

    考虑代码的可读性,使用普通函数

    • 函数体复杂:具体表现就是箭头函数中使用多个三元运算符号,就是不换行,非要在一行内写完,非常恶心!

    • 行数较多

    • 函数内部有大量操作

    普通函数和箭头函数的区别:

    1. 箭头函数没有prototype(原型),所以箭头函数本身没有this
    2. 箭头函数的this在定义的时候继承自外层第一个普通函数的this。
    3. 如果箭头函数外层没有普通函数,严格模式和非严格模式下它的this都会指向window(全局对象)
    4. 箭头函数本身的this指向不能改变,但可以修改它要继承的对象的this。
    5. 箭头函数的this指向全局,使用arguments会报未声明的错误。
    6. 箭头函数的this指向普通函数时,它的argumens继承于该普通函数
    7. 使用new调用箭头函数会报错,因为箭头函数没有constructor
    8. 箭头函数不支持new.target
    9. 箭头函数不支持重命名函数参数,普通函数的函数参数支持重命名
    10. 箭头函数相对于普通函数语法更简洁优雅

    箭头函数的注意事项及不适用场景

    箭头函数的注意事项

    1. 箭头函数一条语句返回对象字面量,需要加括号
    2. 箭头函数在参数和箭头之间不能换行
    3. 箭头函数的解析顺序相对||靠前

    不适用场景:箭头函数的this意外指向和代码的可读性。

    展开全文
  • js中箭头函数和普通函数区别

    千次阅读 2022-05-25 11:01:33
    箭头函数和普通函数 箭头函数相当于匿名函数,并且简化了函数定义。 箭头函数有两种格式,一种只包含一个表达式,连{ … }和return都省略掉了。 还有一种可以包含多条语句,这时候就不能省略{ … }和return。 let ...

    一.箭头函数和普通函数

    箭头函数相当于匿名函数,并且简化了函数定义。
    箭头函数有两种格式,一种只包含一个表达式,连{ … }和return都省略掉了。
    还有一种可以包含多条语句,这时候就不能省略{ … }和return。
    
    let fun = () => {
        console.log('111');
    }
    function fun() {   //普通函数
        console.log('123');
    }
    
    

    二、箭头函数和普通函数的区别

    1. 箭头函数不能作为构造函数,而普通函数可以:

    箭头函数是匿名函数,不能作为构造函数,不能使用new

    let a = function(){
    	console.log('a');
    }
    let b = () => {
       console.log('b');
    }
    console.log(a.prototype)  // {constructor: ƒ}
    console.log(b.prototype)  // undefined
    
    
    let a1 = new a(); 
    let b1 = new b(); //b is not a constructor
    

    2.箭头函数没有原型,而普通函数有

    3.箭头函数不绑定arguments,取而代之用rest参数…解决;普通函数argument绑定了参数列表对象

    function A(a){
      console.log(arguments);
    }
    A(1,2,3,4,5,8);  //  [1, 2, 3, 4, 5, 8, callee: ƒ, Symbol(Symbol.iterator): ƒ]
    
    
    let B = (b)=>{
      console.log(arguments);
    }
    B(2,92,32,32);   // Uncaught ReferenceError: arguments is not defined
    
    
    let C = (...c) => {
      console.log(c);
    }
    C(3,82,32,11323);  // [3, 82, 32, 11323]
    

    4.this指向问题 [重点,也是难点]

    • 箭头函数不改变this指向,this为上层函数作用域的this对象,如果没有上层函数作用域,则指向顶部this(在浏览器中顶部this则是window)。普通函数的this指向该函数的调用者。
    • call, apply, bind会改变普通函数的this,但不会改变箭头函数的this
    var obj = {
      a: 10,
      b: () => {
        console.log(this.a); // undefined
        console.log(this); // Window {postMessage: ƒ, blur: ƒ, focus: ƒ, close: ƒ, frames: Window, …}
      },
      c: function() {
        console.log(this.a); // 10
        console.log(this); // {a: 10, b: ƒ, c: ƒ}
      }
    }
    obj.b(); 
    obj.c();
    
    var obj = {
      a: 10,
      b: function(){
        console.log(this.a); 
      },
      c: function() {
         return ()=>{
               console.log(this.a); //此处a为10
         }
      }
    }
    obj.b(); //10
    obj.c()();//10
    

    箭头函数的 this 永远指向其上下文的 this ,任何方法都改变不了其指向,如 call() , bind() , apply()

    let obj2 = {
        a: 10,
        b: function(n) {
            let f = (n) => n + this.a;
            return f(n);
        },
        c: function(n) {
            let f = (n) => n + this.a;
            let m = {
                a: 20
            };
            return f.call(m,n);
        }
    };
    console.log(obj2.b(1));  // 11
    console.log(obj2.c(1)); // 11
    

    5.箭头函数内不能用yield且不能用作Generator函数,而普通函数可以

    三.箭头函数的使用

    箭头函数有两种格式, 一种只包含一个表达式,没有{…} 和 return
    一种包含多条语句, 这个时候{} return 就不能省略
    在这里插入图片描述注意:
    1.函数体内只包含一个表达式 { … }和return可以省略掉。函数体内包含多条表达式 { … }和return不可以省略掉。
    2.如果要返回一个对象,就要注意,如果是单表达式,这么写的话会报错:x => { foo: x }
    因为和函数体的{ … }有语法冲突,所以要改为:x => ({ foo: x })

    展开全文
  • 箭头函数和普通函数的常见区别

    千次阅读 多人点赞 2022-07-29 15:33:32
    经过上述分析发现普通函数的功能会比箭头函数更强大一些,但这也不是说我们就要避免使用箭头函数。而是应该根据实际的应用场景来选择。对于使用react hooks来开发前端的我而言,基本很少使用普通函数,大部分的箭头...

    一、前言

    使用JS经常会看到如下写法来定义函数:

    第一种:const App= () => {} //箭头函数
    第二种:function App() {}  //普通函数
    

    他们之间除了长的不一样还有一些区别是我们需要注意的,这里给大家介绍一下。


    二、箭头函数和普通函数的常见区别

    1)写法不同

    箭头函数比普通函数更简洁:

    //普通函数
    const sum = function sum(a, b) { 
       return a + b
    }
    //箭头函数 相当于python的匿名函数了
    const sum = (a, b) => a + b
    

    箭头函数的写法跟Python中的匿名函数类似。

    2)箭头函数没有自己的this

    箭头函数不能作为构造函数,也没有自己的this,它只会在自己作用域的上一层继承this。所以箭头函数中this的指向在它在定义时已经确定了,之后不会改变:

    var id = '1';
    var obj = {
      id: '2',
      a: function(){
        console.log(this.id);
      },
      b: () => {
        console.log(this.id);
      }
    };
    obj.a();    // '2'
    obj.b();    // '1'
    new obj.a()  // undefined
    new obj.b()  // Uncaught TypeError: obj.b is not a constructor
    

    3)普通函数有arguments方法,箭头函数没有

    f1(12,23,45); 
    
    //普通函数
    const f1 = function () {
      console.log(arguments);//Arguments(3) [12, 23, 45, callee: (...), Symbol(Symbol.iterator): ƒ]
    }
    
    //箭头函数
    const f1 = () => console.log(arguments);// Throws an error  - arguments is not defined
    //箭头函数可以使用rest语法解决
    const f1 = (...args) => console.log(args);//[12, 23, 45] 
    

    4)箭头函数没有new.target

    new.target是用来检测函数是否被当做构造函数使用,他会返回一个指向构造函数的引用:

    箭头函数打印new.target出现报错

    在这里插入图片描述


    5)箭头函数没有变量提升

    变量提升即将变量声明提升到它所在作用域的最开始的部分,如下面的代码所示:

    func();
    function func(){
    	console.log("aa");
    }
    

    func的调用执行可以定义在函数创建之前,也不会报错,但箭头函数则不行:
    在这里插入图片描述


    6)箭头函数不能作为构造函数使用

    普通函数

     function Cls(a,b) {
        this.a=a
        this.b=b
      }
    
     let obj=new Cls(1,2)
     console.log(obj.a) //1
    

    箭头函数

     let Cls = (a, b) => {
        this.a = a
        this.b = b
      }
    
      let obj = new Cls(1, 2)
      console.log(obj.a)//undefiend
    

    三、总结

    经过上述分析发现普通函数的功能会比箭头函数更强大一些,但这也不是说我们就要避免使用箭头函数。而是应该根据实际的应用场景来选择。对于使用react hooks来开发前端的我而言,基本很少使用普通函数,大部分的箭头函数使用也未造成开发的影响,代码反而简洁了不少。这两者也没有谁优谁劣的说法,看个人喜好来选择也是可以的。没必要在这些问题上花费过多的时间去争论,哪种让自己用起来更舒服用哪种就行。

    展开全文
  • 箭头函数和普通函数之间的区别?

    千次阅读 2022-03-17 21:37:19
    2.1、普通函数和箭头函数的this指向不同。箭头函数中没有this。 let obj = { say: function() { console.log(this) } } obj.say() //{ say: func } let obj2 = { say: () => { console.log(this) } }
  • 箭头函数和普通函数的区别
  • 面试题 es6 箭头函数和普通函数区别
  • 面试官:请说一下箭头函数和普通函数的区别 一.外形不同:箭头函数使用箭头定义,普通函数中没有 二.箭头函数都是匿名函数 普通函数可以有匿名函数,也可以有具体名函数,但是箭头函数都是匿名函数。 三.箭头函数...
  • 1,写法不同 2,箭头函数都是匿名函数 // 具名函数 function func(){ // code } // 匿名函数 let func=function(){ ...5,普通函数的this总是代表它的直接调用者,箭头函数没有自己的this,它的this是继承...
  • 箭头函数和匿名函数有个明显的区别:箭头函数内部的this是词法作用域,由上下文确定。(词法作用域就是定义在词法阶段的作用域。换句话说,词法作用域是由你在写代码时将变量和块作用域写在哪里来决定的,因此当词法...
  • 关于箭头函数和普通函数的区别
  • 箭头函数和普通函数区别
  • 和普通函数的区别: 箭头函数不能用作构造函数,不能用new 箭头函数不能使用arguments,而普通函数内部的arguments对象用来存储传入函数的所有参数。 箭头函数不可以使用super 箭头函数没有prototype属性,没有...
  • JS-ES6中箭头函数和普通函数this指向问题 一、普通函数中的this (1)普通函数中的this代表它的直接调用者,如obj.fn(),fn的this指向就是obj (2)默认情况下,没有直接的调用者,this的指向为window (3)严格模式...
  • JS中箭头函数和普通函数的五种区别
  • js箭头函数和普通函数区别

    千次阅读 2020-04-10 16:23:54
    js箭头函数和普通函数区别 实验环境:nodejs v12.16.1 箭头函数不能作为构造函数,而普通函数可以 箭头函数没有原型,而普通函数有。 箭头函数return可以省略语句块。 箭头函数不绑定arguments(注意:浏览器...
  • JS中箭头函数和普通函数的区别 ES6标准新增了一种新的函数:箭头函数Arrow Function let fn = () => {}; 箭头函数是一种非常好用的语法,其有着简洁的函数声明方法,还有很多的简写方式,下面详细的介绍一些箭头...
  • 箭头函数和普通函数中this的区别 箭头函数:没有重新绑定this的功能 普通函数:具有重新绑定this的功能 1、普通函数中this的绑定情况 实现按钮按下后变大的功能 <!DOCTYPE html> <html lang="en"> <...
  • 为此我特别查了下箭头函数普通函数到底有啥区别,查了MDN文档,是这么说的,箭头函数时es2015引入的,它不提供自身的 this 绑定,也就是说这个函数本身里是没有this的,它里面的this 的值保持为闭合词法上下文的值...
  • 箭头函数普通函数区别可不止this指向不同这一个知识点哦~。 箭头函数的不同点 语法更简洁、直观。 从作用域上层继承this。 bind、callapply对箭头函数没效果。 不绑定arguments对象。 不能使用new关键字...
  • 普通函数this: this总是代表它的直接调用者。 在默认情况下,没找到直接调用者,this指的是window。 在严格模式下,没有直接调用者的函数中的this是undefined。 使用call,apply,bind绑定,this指的是绑定的对象。 ...
  • 目录 一.... 二.箭头函数都是匿名函数 三.箭头函数不能用于构造函数,不能使用new ...四.箭头函数中this的指向不同 ...箭头函数使用箭头定义,普通函数中没有 代码如下: // 普通函数 function func(){ // code }
  • js代码-014面试题--普通函数箭头函数的区别
  • 2. ES6 的箭头函数和以前的普通函数的区别? 3. 箭头函数可以作为构造函数吗?为什么不能作为构造函数呢? 最明显的区别: 箭头函数的this永远指向其上下文的this,任何方法都改变不了其指向,如call(), bind(), ...
  • 前端面试题:箭头函数和普通函数的区别? 箭头函数为什么不能用作构造函数?
  • ES6中的箭头函数和普通函数有什么区别? 1、普通函数的 this 永远指向调用它的那个对象(谁调用,this 就指向谁) 箭头函数没自己的 this,它的 this 永远指向其定义环境,任何方法都不能改变其指向,如 call()、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 47,899
精华内容 19,159
关键字:

箭头函数和普通函数

友情链接: jedec_ddr.rar