精华内容
下载资源
问答
  • 普通函数和箭头函数的区别

    万次阅读 多人点赞 2019-03-24 14:06:13
    普通函数和箭头函数的区别: 箭头函数的this指向规则: 1. 箭头函数没有prototype(原型),所以箭头函数本身没有this 2. 箭头函数的this指向在定义的时候继承自外层第一个普通函数的this。 3. 不能直接修改箭头函数的...

    详解箭头函数和普通函数的区别以及箭头函数的注意事项、不适用场景

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

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

    箭头函数的this指向规则:

    1. 箭头函数没有prototype(原型),所以箭头函数本身没有this
    let a = () =>{};
    console.log(a.prototype); // undefined
    
    1. 箭头函数的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指向
    }
    

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

    • 箭头函数的this指向定义时所在的外层第一个普通函数,跟使用位置没有关系。
    • 被继承的普通函数的this指向改变,箭头函数的this指向会跟着改变
    1. 不能直接修改箭头函数的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

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

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

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

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

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

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

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

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

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

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

    箭头函数的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('外层第二个普通函数的参数');
    

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

    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参数有两点需要注意:

    • rest必须是函数的最后一位参数:
    let a = (first, ...rest, three) => {
      console.log(first, rest,three); // 报错:Rest parameter must be last formal parameter
    };
    a(1, 2, 3, 4);
    
    • 函数的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调用的。

    • 箭头函数的this指向全局对象,在箭头函数中使用箭头函数会报错
    let a = () => {
      console.log(new.target); // 报错:new.target 不允许在这里使用
    };
    a();
    
    • 箭头函数的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);
    

    箭头函数相对于普通函数语法更简洁优雅:
    讲道理,语法上的不同,也属与它们两个的区别!

    • 箭头函数都是匿名函数,并且都不用写function
    • 只有一个参数的时候可以省略括号:
    var f = a => a; // 传入a 返回a
    
    • 函数只有一条语句时可以省略{}return
    var f = (a,b,c) => a; // 传入a,b,c 返回a
    
    • 简化回调函数,让你的回调函数更优雅:
    [1,2,3].map(function (x) {
      return x * x;
    }); // 普通函数写法 
    [1,2,3].map(x => x * x); // 箭头函数只需要一行
    

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

    箭头函数的注意事项

    • 一条语句返回对象字面量,需要加括号,或者直接写成多条语句的return形式,否则像func中演示的一样,花括号会被解析为多条语句的花括号,不能正确解析
    var func1 = () => { foo: 1 }; // 想返回一个对象,花括号被当成多条语句来解析,执行后返回undefined
    var func2 = () => ({foo: 1}); // 用圆括号是正确的写法
    var func2 = () => {
      return {
        foo: 1 // 更推荐直接当成多条语句的形式来写,可读性高
      };
    };
    
    • 箭头函数在参数和箭头之间不能换行!
    var func = ()
               => 1;  // 报错: Unexpected token =>
    
    • 箭头函数的解析顺序相对靠前
      MDN: 虽然箭头函数中的箭头不是运算符,但箭头函数具有与常规函数不同的特殊运算符优先级解析规则
    let a = false || function() {}; // ok
    let b = false || () => {}; // Malformed arrow function parameter list
    let c = false || (() => {}); // ok
    

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

    • 定义字面量方法,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!

    • 回调函数的动态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意外指向和代码的可读性。
    展开全文
  • 箭头函数与普通函数的区别详解

    万次阅读 多人点赞 2020-11-24 16:22:23
    箭头函数和普通函数的区别 一.外形不同:箭头函数使用箭头定义,普通函数中没有 代码实例如下: // 普通函数 function func(){ // code } // 箭头函数 let func=()=>{ // code } 二.箭头函数都是匿名函数 普通...

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

    一.外形不同:箭头函数使用箭头定义,普通函数中没有
    代码实例如下:

    // 普通函数
    function func(){
      // code
    }
    // 箭头函数
    let func=()=>{
      // code
    }
    

    二.箭头函数都是匿名函数
    普通函数可以有匿名函数,也可以有具体名函数,但是箭头函数都是匿名函数。
    代码实例如下:

    // 具名函数
    function func(){
      // code
    }
     
    // 匿名函数
    let func=function(){
      // code
    }
    
    // 箭头函数全都是匿名函数
    let func=()=>{
      // code
    }
    

    三.箭头函数不能用于构造函数,不能使用new
    普通函数可以用于构造函数,以此创建对象实例。
    代码实例如下:

    function Person(name,age){
       this.name=name;
       this.age=age;
    }
    let admin=new Person("恩诺小弦",18);
    console.log(admin.name);
    console.log(admin.age);
    

    代码运行如下:

    恩诺小弦
    18
    

    Person用作构造函数,通过它可以创建实例化对象。
    但是构造函数不能用作构造函数。

    四.箭头函数中this的指向不同
    在普通函数中,this总是指向调用它的对象,如果用作构造函数,this指向创建的对象实例。
    1.箭头函数本身不创建this
    也可以说箭头函数本身没有this,但是它在声明时可以捕获其所在上下文的this供自己使用。
    注意:this一旦被捕获,就不再发生变化

    var webName="捕获成功";
    let func=()=>{
      console.log(this.webName);
    }
    func();
    

    运行结果如下:

    捕获成功
    

    代码分析:箭头函数在全局作用域声明,所以它捕获全局作用域中的this,this指向window对象。

    例子:

    var name = "恩诺1";
    function wrap(){
      this.name="恩诺2";
      let func=() => {
        console.log(this.name);
      }
      func();
    }
    let en=new wrap();
    

    运行结果如下:

    恩诺2
    

    代码分析:
    (1)wrap()用作构造函数。
    (2)使用new调用wrap()函数之后,此函数作用域中的this指向创建的实例化对象。
    (3)箭头函数此时被声明,捕获这个this。
    (4)所以打印的是恩诺2,而不是恩诺1。
    2.结合call(),apply()方法使用
    箭头函数结合call(),apply()方法调用一个函数时,只传入一个参数对this没有影响。

    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
    

    3.箭头函数不绑定arguments,取而代之用rest参数…解决
    每一个普通函数调用后都具有一个arguments对象,用来存储实际传递的参数。但是箭头函数并没有此对象。

    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.其他区别
    (1).箭头函数不能Generator函数,不能使用yeild关键字。
    (2).箭头函数不具有prototype原型对象。
    (3).箭头函数不具有super。
    (4).箭头函数不具有new.target。

    总结
    (1).箭头函数的 this 永远指向其上下文的 this ,任何方法都改变不了其指向,如 call() , bind() , apply()
    (2).普通函数的this指向调用它的那个对象

    参考
    https://www.cnblogs.com/biubiuxixiya/p/8610594.html
    https://www.softwhy.com/article-9330-1.html

    展开全文
  • 文章目录一、箭头函数二、与普通函数的区别1.箭头函数不会创建自己的this2.箭头函数继承而来的this指向永远不变(重要)3.call()、apply()、bind()无法改变箭头函数中this的指向4.箭头函数不绑定arguments,取而代之...

    一、箭头函数

    // 箭头函数
    let fun = (name) => {
        // 函数体
        return `Hello ${name} !`;
    };
    
    // 等同于
    let fun = function (name) {
        // 函数体
        return `Hello ${name} !`;
    };
    

    二、与普通函数的区别

    1.箭头函数不会创建自己的this

    箭头函数没有自己的this,它会捕获自己在定义时(注意,是定义时,不是调用时)所处的外层执行环境的this,并继承这个this值。所以,箭头函数中this的指向在它被定义的时候就已经确定了,之后永远不会改变。

    来看个例子:

    var id = 'Global';
    
    function fun1() {
        // setTimeout中使用普通函数
        setTimeout(function(){
            console.log(this.id);
        }, 2000);
    }
    
    function fun2() {
        // setTimeout中使用箭头函数
        setTimeout(() => {
            console.log(this.id);
        }, 2000)
    }
    
    fun1.call({id: 'Obj'});     // 'Global'
    
    fun2.call({id: 'Obj'});     // 'Obj'
    
    • 函数fun1中的setTimeout中使用普通函数,2秒后函数执行时,这时函数其实是在全局作用域执行的,所以this指向Window对象,this.id就指向全局变量id,所以输出’Global’。
    • 但是函数fun2中的setTimeout中使用的是箭头函数,这个箭头函数的this在定义时就确定了,它继承了它外层fun2的执行环境中的this,而fun2调用时this被call方法改变到了对象{id: ‘Obj’}中,所以输出’Obj’。

    再来看另一个例子:

    var id = 'GLOBAL';
    var obj = {
      id: 'OBJ',
      a: function(){
        console.log(this.id);
      },
      b: () => {
        console.log(this.id);
      }
    };
    
    obj.a();    // 'OBJ'
    obj.b();    // 'GLOBAL'
    
    • 对象obj的方法a使用普通函数定义的,普通函数作为对象的方法调用时,this指向它所属的对象。所以,this.id就是obj.id,所以输出’OBJ’。
    • 但是方法b是使用箭头函数定义的,箭头函数中的this实际是继承它定义时的外层执行环境的this,它定义时所处的外层执行环境就是全局环境,所以指向Window对象,所以输出’GLOBAL’。(定义对象的大括号{}是无法形成一个单独的执行环境的,它依旧是处于全局执行环境中

    2.箭头函数继承而来的this指向永远不变(重要)

    箭头函数继承而来的this指向永远不变。对象obj的方法b是使用箭头函数定义的,这个函数中的this就永远指向它定义时所处的全局执行环境中的this,即便这个函数是作为对象obj的方法调用,this依旧指向Window对象。

    3.call()、apply()、bind()无法改变箭头函数中this的指向

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

    var id = 'Global';
    
    // 箭头函数定义在全局作用域
    let fun1 = () => {
        console.log(this.id)
    };
    
    fun1();     // 'Global'
    // this的指向不会改变,永远指向Window对象
    fun1.call({id: 'Obj'});     // 'Global'
    fun1.apply({id: 'Obj'});    // 'Global'
    fun1.bind({id: 'Obj'})();   // 'Global'
    

    4.箭头函数不绑定arguments,取而代之用rest参数…解决

    箭头函数没有自己的arguments对象。在箭头函数中访问arguments实际上获得的是外层局部(函数)执行环境中的值。

    // 例子一
    let fun = (val) => {
        console.log(val);   // 111
        console.log(arguments); 
            // Uncaught ReferenceError: arguments is not defined
        // 因为外层全局环境没有arguments对象
    };
    fun(111);
    
    // 例子二
    function outer(val1, val2) {
        let argOut = arguments;
        console.log(argOut);    //Arguments(2) [111, 222, callee: ƒ, Symbol(Symbol.iterator): ƒ]
        let fun = () => {
            let argIn = arguments;
            console.log(argIn);  //Arguments(2) [111, 222, callee: ƒ, Symbol(Symbol.iterator): ƒ]
            console.log(argOut === argIn);  // true,箭头函数中访问arguments是外层局部(函数)执行环境中的值。
        };
        fun();
    }
    outer(111, 222);
    

    rest参数用于获取函数的多余参数,这样就不需要使用arguments对象了

    var foo = (...args) => {
      return args[0]
    }
    console.log(foo(1))    //1
    

    5.不能使用new操作符(作为构造函数使用)

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

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

    构造函数的new操作分为四步:

    1. 创建一个空对象
    2. 链接到原型
    3. 绑定this值
    4. 返回新对象

    但是,箭头函数没有原型属性,没有自己的this,它的this其实是继承了外层执行环境中的this,且this指向永远不会随在哪里调用、被谁调用而改变,所以箭头函数不能作为构造函数使用,或者说构造函数不能定义成箭头函数,否则用new调用时会报错。

    6.不能使用原型属性

    箭头函数没有原型属性。

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

    7.不能简单返回对象字面量

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

    如果要返回对象字面量,用括号包裹字面量

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

    8.箭头函数不能换行

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

    参考:https://www.jianshu.com/p/eca50cc933b7

    本文链接:https://blog.csdn.net/qq_39903567/article/details/115208019

    展开全文
  • 箭头函数与普通函数区别

    千次阅读 2020-11-23 16:17:39
    箭头函数与普通函数区别 箭头函数是匿名函数不能作为构造函数不能使用new 箭头函数不绑定arguments,需要用运算符解决…解决 箭头函数不绑定this,会捕获其所在的this值,作为自己的this值 箭头函数通过call()或apply()...

    箭头函数与普通函数区别

    箭头函数是匿名函数不能作为构造函数不能使用new
    箭头函数不绑定arguments,需要用运算符解决…解决
    箭头函数不绑定this,会捕获其所在的this值,作为自己的this值
    箭头函数通过call()或apply()调用一个函数,只传入了一个参数,对this并没有影响.
    箭头函数没有原型属性

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

    在这里插入图片描述
    箭头函数相当于匿名函数,并且简化了函数定义。箭头函数有两种格式,一种只包含一个表达式,连{ … }和return都省略掉了。还有一种可以包含多条语句,这时候就不能省略{ … }和return。

    二、箭头函数不绑定arguments,取而代之需要用展开运算符解决…解决

    在这里插入图片描述

    三、箭头函数不绑定this,会捕获其所在的上下文的this值,作为自己的this值

    在这里插入图片描述

    四、箭头函数通过 call() 或 apply() 方法调用一个函数时,只传入了一个参数,对 this 并没有影响。

    在这里插入图片描述

    五、箭头函数没有原型属性

    在这里插入图片描述

    展开全文
  • 构造函数与普通函数的区别

    千次阅读 2019-05-26 16:58:44
    构造函数: 构造函数的作用: 给对应的对象进行初始化。 构造函数的定义的格式: 修饰符 函数名(形式参数){ 函数体... } 构造函数要注意的细节: 1. 构造函数 是没有返回值类型的。 2. 构造函数函数名...
  • js箭头函数和普通函数的区别

    千次阅读 2020-05-24 20:54:40
    (1)普通函数中的this: 在简单调用中,非严格模式下,指向window。严格模式下,为undefined。 function parent() { console.log(this); } parent();// window 'use strict'; function parent() { console...
  • 普通函数和箭头函数的this

    千次阅读 多人点赞 2019-02-11 22:06:50
    普通函数的this 1. this总是代表它的直接调用者, 例如 obj.func ,那么func中的this就是obj 2. 调用的时候,没有任何前缀,则指向window,new的时候,指向new出来的对象。 3.在默认情况(非严格模式下,未使用 'use...
  • 普通函数和构造函数的区别

    千次阅读 2018-11-13 13:55:57
    普通函数和构造函数的区别 在命名规则上,构造函数一般是首字母大写,普通函数遵照小驼峰式命名法。 在函数调用的时候: function fn() { }  构造函数:1. new fn( )  2 .构造函数内部会创建一个新的对象,即...
  • Bomb的箭头函数转成普通函数该怎么转? ```js query.find().then(todos => { todos.set('aab', "3333"); todos.saveAll().then(res => { // 成功批量修改 console.log(res,'ok') }).catch(err => { ...
  • 箭头函数与普通函数的区别

    千次阅读 2018-11-23 14:51:58
    箭头函数与普通函数的区别 1.没有this、super、arguments和new.target绑定, 箭头函数中的this、super、arguments及new.target这些值由外围最近一层非箭头函数决定 2.不能通过new关键字调用箭头函数没有construct...
  • 箭头函数是ES6的API,相信很多人都知道,因为其语法上相对于普通函数更简洁,深受大家的喜爱。就是这种我们日常开发中一直在使用的API,大部分同学却对它的了解程度还是不够深… 普通函数和箭头函数的区别: 箭头...
  • JS中构造函数与普通函数的区别

    千次阅读 2020-08-12 11:10:51
    //构造函数也是一个普通函数,创建方式和普通函数一样。 function Foo(){} Foo();//普通函数调用方式 var f = new Foo();//构造函数调用方式 普通函数调用方式:直接调用person(); 构造函数调用方式:需要使用new...
  • JS 中构造函数和普通函数的区别

    万次阅读 多人点赞 2018-10-04 19:03:53
    1、构造函数也是一个普通函数,创建方式和普通函数一样,但构造函数习惯上首字母大写 2、构造函数和普通函数的区别在于:调用方式不一样。作用也不一样(构造函数用来新建实例对象) 3、调用方式不一样。  ...
  • 【js】理解普通函数和箭头函数的区别点

    万次阅读 多人点赞 2019-05-15 15:12:48
    普通函数在es5中就有了,箭头函数是es6中出现的函数形式,当然也可以继续用普通函数普通函数大家知道: 形式基本一致 来看看箭头函数: 开发时根据实际情况可以省略一些东西 单条处理可以省略return和{大括号} ...
  • 随机变量与普通函数的区别

    千次阅读 2021-03-02 20:42:30
  • JS构造函数与普通函数的区别

    千次阅读 2018-12-14 23:02:32
    1、直观上 构造函数都应该以 一个大写字母开头: function Foo(){...} ...构造函数可以作为普通函数使用,普通函数也可以作为构造函数来用;首字母大小写仅仅是为了在开发中能易于区分他们。 ...
  • ES6箭头函数与普通函数的区别

    千次阅读 2019-04-05 20:23:58
    箭头函数与普通函数的区别 作为ES6中新加入的箭头函数语法,深受广大开发人员的喜爱,也是平时前端面试过程中经常会被提及问道的典型题目。它不仅简化了我们的代码,而且也让开发人员摆脱了“飘忽不定”的this指向...
  • 静态(static)函数与普通函数

    万次阅读 2018-07-14 16:21:58
    static函数与普通函数的区别:  1.用static修饰的函数,限定在本源码文件中使用,不能被本源码文件以外的代码文件调用。  2.普通的函数,默认是extern的,也就是说,可以被其它代码文件调用该函数。    若在...
  • 内联函数和普通函数最大的区别在于内部的实现方面,当普通函数在被调用时,系统首先跳跃到该函数的入口地址,执行函数体,执行完成后,再返回到函数调用的地方,函数始终只有一个拷贝; 而内联函数则不需要进行一个...
  • 复制代码普通函数 var sum = function (a, b){ return a + b; } 复制代码区别 之前看阮一峰前辈 es6 文章里提过这个知识点,但是昨天面试被问到了,只回答出了this,所以赶紧抽空整理下知识点,查缺补漏,下面开始...
  • Qt 普通函数和槽函数区别

    万次阅读 2019-07-01 20:59:52
    槽用于接收信号,但它们是普通的对象成员函数。一个槽并不知道是否有任何信号与自己相连接。而且,对象并不了解具体的通信机制。 你可以将很多信号与单个的槽进行连接,也可以将单个的信号与很多的槽进行连接,甚至...
  • 文章目录1 公有继承时三种类型的函数行为1.1 纯虚函数 (pure virtual)1.2 普通函数**1.2.1 方法一****1.2.2 方法二**1.3 非虚函数2 重写 (override)小结 1 公有继承时三种类型的函数行为 公有继承包含两部分:一是...
  • C++普通函数,普通成员函数、静态成员函数的区别

    千次阅读 多人点赞 2017-05-13 22:24:53
    1普通函数:属于全局函数,不受具体类和对象的限制,可以直接调用。 例如: void printf() { printf("Hello World"); } 2普通成员函数:C++ 普通成员函数本质上是一个包含指向具体对象this指针的普通函数,即...
  • VUE的箭头函数与普通函数的区别

    千次阅读 2019-03-30 01:44:29
    在做vue项目时用到了axios,但是发现axios请求之后的回调函数里this并不指向当前vue实例,从而导致浏览器报错。 出错代码及结果: created : function(){ axios.get('static/data.json').then(...
  • 问:内联函数、静态函数和普通函数之间的区别?答:1.内联函数和普通函数最大的区别在于内部的实现方面,当普通函数在被调用时,系统首先跳跃到该函数的入口地址,执行函数体,执行完成后,再返回到函数调用的地方,...
  • 在c++中普通函数与 内联函数的区别

    千次阅读 多人点赞 2017-10-24 18:47:22
    普通函数的调用 a.当代码执行到函数调用指令时,程序将在函数调用后立即存储该指令的地址,同时将参数复制到堆栈中; b.然后跳到标记函数起点的内存单元当中,执行函数代码,将返回值放回到寄存器当中; c.跳回到...
  • 回调函数和普通函数有什么区别?

    千次阅读 2019-08-06 10:07:11
    普通函数与回调函数主要是在调用方式上有区别: 1、对普通函数的调用: 调用程序发出对普通函数的调用后,程序执行立即转向被调用函数执行,直到被调用函数执行完毕后,再返回调用程序继续执行。从发出调用的程序的...
  • static函数与普通函数有什么区别

    千次阅读 2019-01-08 22:34:38
    static函数与普通函数的区别:  用static修饰的函数,本限定在本源码文件中,不能被本源码文件以外的代码文件调用。而普通的函数,默认是extern的,也就是说,可以被其它代码文件调用该函数。  在函数的返回类型前...
  • es6中的箭头函数和普通函数有什么区别? 1、普通函数中的this总是指向调用它的那个对象,箭头函数没有自己的this,他的this永远指向其定义环境,任何方法都改变不了其指向,如call()、bind()、apply()。(正是因为...
  • 匿名函数和普通函数的区别

    千次阅读 2018-06-26 10:42:00
    匿名函数:如 var a=...普通函数: function abc(){ return 1 }; 此函数声明了一个名为abc的函数。 注意:使用匿名函数表达式时,函数的调用语句,必须放在函数声明语句之后!!! 例如: Method1(); // ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 953,697
精华内容 381,478
关键字:

普通函数