Javascript 中call的使用

淩亂°似流年 2024-02-17 15:13 73阅读 0赞

Javascript中call的使用自己感觉蛮纠结的，根据文档很好理解，其实很难确定你是否真正的理解。

call 方法  
应用于：Function 对象  
调用一个对象的一个方法，以另一个对象替换当前对象。  
call(\[thisObj\[,arg1\[, arg2\[, \[,.argN\]\]\]\]\])  
参数：  
thisObj  
可选项。将被用作当前对象的对象。  
arg1, arg2, , argN  
可选项。将被传递方法参数序列。  
说明：  
call 方法可以用来代替另一个对象调用一个方法。call 方法可将一个函数的对象上下文从初始的上下文改变为由 thisObj 指定的新对象。如果没有提供 thisObj 参数，那么 Global 对象被用作 thisObj。

1.最基本的理解：示例1

自定义一个类，该类有一个方法showTxt，用来显示当前对象的name值。

创建一个对象，并且该对象的name值等于test1。

使用call方法，使新创建的对象obj添加Class1类的showTxt方法，即把Class1类中的this.showTxt中的this指定成obj，这样obj就有了showTxt方法。弹出"test1"。

function
       
       
         Class1(){
         
        
       
       
        this
       
       
        .showTxt 
       
       
        =
       
       
         
       
       
        function
       
       
        (){alert(
       
       
        this
       
       
        .name)}
    }
    
       
       
        var
       
       
         obj 
       
       
        =
       
       
         
       
       
        new
       
       
         Object();
    obj.name
       
       
        =
       
       
        "
       
       
        test1
       
       
        "
       
       
        
    Class1.call(obj);
    obj.showTxt();
       
       
        //
       
       
        test1
       
       
        
    
       
       
        alert(obj.showTxt);
       
       
        //
       
       
        function(){alert(this.name)}

这个例子很容易理解。

2.再看一个稍微深入的理解

示例2：创建Class1的实例，让这个实例调用showTxt方法返回这个实例的name值，因为这个实现没有name值所以返回undefine.

function
       
       
         Class1(){
         
        
       
       
        this
       
       
        .showTxt 
       
       
        =
       
       
         
       
       
        function
       
       
        (){alert(
       
       
        this
       
       
        .name)}
    }
    
       
       
        var
       
       
         class1 
       
       
        =
       
       
         
       
       
        new
       
       
         Class1();
    class1.showTxt();
       
       
        //
       
       
        undefined
       
       
        
    
       
       
        alert(class1.showTxt);
       
       
        //
       
       
        function(){alert(this.name)}

示例3：下面就给Class1添加个name值，这时class1再调用showTxt方法，会返回class1，这是因为给类添加了name值，所以实例的name也由undefine变成了class1.

function
       
       
         Class1(){
         
        
       
       
        this
       
       
        .name 
       
       
        =
       
       
         
       
       
        '
       
       
        class1
       
       
        '
       
       
        ;
       
       
        //
       
       
        添加name值
       
       
        
    
       
       
            
       
       
        this
       
       
        .showTxt 
       
       
        =
       
       
         
       
       
        function
       
       
        (){alert(
       
       
        this
       
       
        .name)}
    }
    
       
       
        var
       
       
         class1 
       
       
        =
       
       
         
       
       
        new
       
       
         Class1();
    class1.showTxt();
       
       
        //
       
       
        class1
       
       
        
    
       
       
        alert(class1.showTxt);
       
       
        //
       
       
        function(){alert(this.name)}

示例4：Class1.call(obj) 这个操作把Class1中的this.name,this.showTxt里的this替换成了obj，所以就变成了obj.name='class1'，所以obj.showTxt在执行时返回class1。

function
       
       
         Class1(){
         
        
       
       
        this
       
       
        .name 
       
       
        =
       
       
         
       
       
        '
       
       
        class1
       
       
        '
       
       
        ;
       
       
        //
       
       
        添加name值
       
       
        
    
       
       
            
       
       
        this
       
       
        .showTxt 
       
       
        =
       
       
         
       
       
        function
       
       
        (){alert(
       
       
        this
       
       
        .name)}
    }
    
       
       
        function
       
       
         Class2(){
         
        
       
       
        this
       
       
        .name 
       
       
        =
       
       
         
       
       
        '
       
       
        class2
       
       
        '
       
       
        ;
    }
    
       
       
        var
       
       
         class2 
       
       
        =
       
       
         
       
       
        new
       
       
         Class2();
    Class1.call(class2);
    alert(class2.showTxt);
       
       
        //
       
       
        function(){alert(this.name)}
       
       
        
    
       
       
        class2.showTxt();
       
       
        //
       
       
        class1

示例5：如果在Class1.call(obj);之后再添加obj.name = 'test1',最后结果会输入test1，原因显而易见。

function
       
       
         Class1(){
         
        
       
       
        this
       
       
        .name 
       
       
        =
       
       
         
       
       
        '
       
       
        class1
       
       
        '
       
       
        ;
       
       
        //
       
       
        添加name值
       
       
        
    
       
       
            
       
       
        this
       
       
        .showTxt 
       
       
        =
       
       
         
       
       
        function
       
       
        (){alert(
       
       
        this
       
       
        .name)}
    }
    
       
       
        function
       
       
         Class2(){
         
        
       
       
        this
       
       
        .name 
       
       
        =
       
       
         
       
       
        '
       
       
        class2
       
       
        '
       
       
        ;
    }
    
       
       
        var
       
       
         class2 
       
       
        =
       
       
         
       
       
        new
       
       
         Class2();
    Class1.call(class2);
    class2.name 
       
       
        =
       
       
         
       
       
        '
       
       
        test1
       
       
        '
       
       
        ;
       
       
        //
       
       
        重定义obj.name值
       
       
        
    
       
       
        alert(class2.showTxt);
       
       
        //
       
       
        function(){alert(this.name)}
       
       
        
    
       
       
        class2.showTxt();
       
       
        //
       
       
        test1

上面的例子call的都是一个对象的实例，接下来的案例把对象的实例直接换成函数，看看执行结果会发生哪些变化

3.把call方法的第一参数由实例换成函数看看会怎么

示例6：Class2是一个function对象的引用,在执行Class1.call(Class2)时this.showTxt里的this被替换成了Class2。这样Class2就有了showTxt方法，Class2.showTxt()执行时会返回Class2.name的值，因为Class2并未定义name值，所以会返回undefined。

Class2函数里的this.name是由Class2创建实例的name值，并不是Class2.name，这两个值有时会让我迷糊。

function
       
       
         Class1(){
         
        
       
       
        this
       
       
        .showTxt 
       
       
        =
       
       
         
       
       
        function
       
       
        (){alert(
       
       
        this
       
       
        .name)}
    }
    
       
       
        function
       
       
         Class2(){
         
        
       
       
        this
       
       
        .name 
       
       
        =
       
       
         
       
       
        '
       
       
        class2
       
       
        '
       
       
        ;
    }
    Class1.call(Class2);
    alert(Class2.showTxt);
       
       
        //
       
       
        function(){alert(this.name)}
       
       
        
    
       
       
        Class2.showTxt();
       
       
        //
       
       
        undefined

4.接着看下面的例子

示例7：class1.showTxt.call(class2);之所以会返回class2是因为function()\{alert(this.name)\}这里的this被call指定成了class2，变成了alert(class2.name)，所以会返回class2.

alert(class2.showTxt)返回undefined，说明并未定义class2.showTxt方法。

function Class1(){
          
        this.showTxt = function(){alert(this.name)}
    }
    function Class2(){
          
        this.name = 'class2';
    }
    var class1 = new Class1();
    var class2 = new Class2();
    class1.showTxt.call(class2);//class2
    alert(class2.showTxt);//undefined

因为并为给class2添加showTxt方法，所以提示该错误。如果在这个调用之前添加Class1.call(class2);这个调用就OK了

Class1.call(class2);
    class2.showTxt();
       
       
        //
       
       
        class1

示例8：这个例子都会返回undefined

function Class1(){
          
        this.showTxt = function(){alert(this.name)}
    }
    function Class2(){
          
        this.name = 'class2';
    }
    var class1 = new Class1();
    class1.showTxt.call(Class2);//undefined
    alert(Class2.showTxt);//undefined

5.在使用call时如果调用函数里没有this会怎么样

示例9：

function
       
       
         add(a,b){
         
        alert(a
       
       
        +
       
       
        b);
    }
    
       
       
        function
       
       
         sub(a,b){
         
        alert(a
       
       
        -
       
       
        b);
    }
    add.call(sub,
       
       
        3
       
       
        ,
       
       
        1
       
       
        );
       
       
        //
       
       
        4

结果返回4，add.call(sub,3,1)在执行过程中，sub做为add函数中this的替代品出现，但是因为add里没有用到this，所以sub函数直接忽略，所以结果是4。

所以实际执行如下：返回4。

function
       
       
         add(a,b){
         
        alert(a
       
       
        +
       
       
        b);
    }
    add(
       
       
        3
       
       
        ,
       
       
        1
       
       
        );
       
       
        //
       
       
        4

6.不错，接下来再理解一个怪异的形式

示例10：

function
       
       
         f1(){
         
        alert(
       
       
        1
       
       
        );
    }
    
       
       
        function
       
       
         f2(){
         
        alert(
       
       
        2
       
       
        )
    }
    
       
       
        var
       
       
         f3 
       
       
        =
       
       
         f1.call;
    f1.call(f2);
       
       
        //
       
       
        1
       
       
        
    
       
       
        f3.call(f2);
       
       
        //
       
       
        2

f1.call(f2);比较好理解，如果不理解看上边的case，但如何理解f3.call(f2)会返回2呢，为了方便理解进行一下等效变化为f1.call.call(f2)，这时会发现实际上是f1.call方法call调用了f2，那f1怎么又会有call方法呢？call, apply都属于Function.[prototype][]的一个方法,它是JavaScript引擎内在实现的,因为属于Function.prototype,所以每个Function对象实例,也就是每个方法都有call, apply属性。

在理解f1.call.call(f2)时我们首先要知道call方法到底是如何执行的，这样才能f1.call.call(f2)如何执行。

示例11：

引用[JK][]写的一个用apply实现call的方法：

function
       
       
         jsCall(oThis){
         
       
       
        //
       
       
        这里的jsCall就是Call
       
       
        
    
       
       
            
       
       
        var
       
       
         argsNew 
       
       
        =
       
       
         [];
        
       
       
        for
       
       
        (
       
       
        var
       
       
         i
       
       
        =
       
       
        1
       
       
        ;i
       
       
        <
       
       
        arguments.length;i
       
       
        ++
       
       
        ){
         
            argsNew.push(arguments[i]);
        }
        
       
       
        return
       
       
         
       
       
        this
       
       
        .apply(oThis,argsNew);
    }
    Function.prototype.jsCall 
       
       
        =
       
       
         jsCall;

或简写成

function
       
       
         jsCall(oThis){
         
       
       
        //
       
       
        这里的jsCall就是Call
       
       
        
    
       
       
            
       
       
        var
       
       
         argsNew 
       
       
        =
       
       
         [].slice.call(arguments,
       
       
        1
       
       
        )    
        
       
       
        return
       
       
         
       
       
        this
       
       
        .apply(oThis,argsNew);
    }
    Function.prototype.jsCall 
       
       
        =
       
       
         jsCall;

这样就得到了一个和call一样功能的jsCall.

接下来构建两个函数f1,f2

function
       
       
         f1(a){
         
        alert([
       
       
        this
       
       
        ,a,
       
       
        '
       
       
        f1
       
       
        '
       
       
        ]);
    }
    f1(
       
       
        11
       
       
        );
       
       
        //
       
       
        [object Window],11,f1
       
       
        
    
       
       
        function
       
       
         f2(a){
         
        alert([
       
       
        this
       
       
        ,a,
       
       
        '
       
       
        f2
       
       
        '
       
       
        ]);
    }
    f2(
       
       
        22
       
       
        );
       
       
        //
       
       
        [object Window],11,f2

用jsCall把f1中的this替换成f2

function
       
       
         f1(a){
         
        alert([
       
       
        this
       
       
        ,a,
       
       
        '
       
       
        f1
       
       
        '
       
       
        ]);
    }
    
       
       
        function
       
       
         f2(a){
         
        alert([
       
       
        this
       
       
        ,a,
       
       
        '
       
       
        f2
       
       
        '
       
       
        ]);
    }
    f1.jsCall(f2,
       
       
        11
       
       
        );
       
       
        //
       
       
        function f2(a){alert([this, a, "f2"]);},11,f1

执行结果发现\[object Window\]被替换成f2函数

function
       
       
         jsCall(oThis){
         
       
       
        //
       
       
        这里的jsCall就是Call
       
       
        
    
       
       
            
       
       
        var
       
       
         argsNew 
       
       
        =
       
       
         [].slice.call(arguments,
       
       
        1
       
       
        )    
        
       
       
        return
       
       
         
       
       
        this
       
       
        .apply(oThis,argsNew);
    }
    Function.prototype.jsCall 
       
       
        =
       
       
         jsCall;
    
       
       
        function
       
       
         f1(a){
         
        alert([
       
       
        this
       
       
        ,a,
       
       
        '
       
       
        f1
       
       
        '
       
       
        ]);
    }
    
       
       
        function
       
       
         f2(a){
         
        alert([
       
       
        this
       
       
        ,a,
       
       
        '
       
       
        f2
       
       
        '
       
       
        ]);
    }
    f1.jsCall.jsCall(f2,
       
       
        11
       
       
        );
       
       
        //
       
       
        11,,f2

在执行f1.jsCall.jsCall(f2,11);时返回11,,f2，为什么会返回这个结果，重点来了:)

f1.jsCall方法：

alert(f1.jsCall);
    
       
       
        //
       
       
        返回
       
       
        
    //
       
       
        function jsCall(oThis) {
         
       
       
        
    //
       
       
            var argsNew = [].slice.call(arguments, 1);
       
       
        
    //
       
       
            return this.apply(oThis, argsNew);
       
       
        
    //
       
       
        }

所以f1.jsCall.jsCall可以替换成jsCall.jsCall看一下执行结果

function
       
       
         jsCall(oThis){
         
       
       
        //
       
       
        这里的jsCall就是Call
       
       
        
    
       
       
            
       
       
        var
       
       
         argsNew 
       
       
        =
       
       
         [].slice.call(arguments,
       
       
        1
       
       
        )    
        
       
       
        return
       
       
         
       
       
        this
       
       
        .apply(oThis,argsNew);
    }
    Function.prototype.jsCall 
       
       
        =
       
       
         jsCall;
    
       
       
        function
       
       
         f1(a){
         
        alert([
       
       
        this
       
       
        ,a,
       
       
        '
       
       
        f1
       
       
        '
       
       
        ]);
    }
    
       
       
        function
       
       
         f2(a){
         
        alert([
       
       
        this
       
       
        ,a,
       
       
        '
       
       
        f2
       
       
        '
       
       
        ]);
    }
    jsCall.jsCall(f2,
       
       
        11
       
       
        );
       
       
        //
       
       
        11,,f2

接着分析

jsCall在执行的过程中，return this.apply(oThis,argsNew);里的this被替换成了f2，11做为参数传给了(oThis,argsNew)，变成了f2.apply(11);

function
       
       
         jsCall(oThis){
         
       
       
        //
       
       
        这里的jsCall就是Call
       
       
        
    
       
       
            
       
       
        var
       
       
         argsNew 
       
       
        =
       
       
         [].slice.call(arguments,
       
       
        1
       
       
        )    
        
       
       
        return
       
       
         
       
       
        this
       
       
        .apply(oThis,argsNew);
    }
    Function.prototype.jsCall 
       
       
        =
       
       
         jsCall;
    
       
       
        function
       
       
         f1(a){
         
        alert([
       
       
        this
       
       
        ,a,
       
       
        '
       
       
        f1
       
       
        '
       
       
        ]);
    }
    
       
       
        function
       
       
         f2(a){
         
        alert([
       
       
        this
       
       
        ,a,
       
       
        '
       
       
        f2
       
       
        '
       
       
        ]);
    }
    f2.apply(
       
       
        11
       
       
        );
       
       
        //
       
       
        11,,f2

返回结果跟f1.jsCall.jsCall(f2,11)一样。

回过头来看

function
       
       
         f1(){
         
        alert(
       
       
        1
       
       
        );
    }
    
       
       
        function
       
       
         f2(){
         
        alert(
       
       
        2
       
       
        )
    }
    
       
       
        var
       
       
         f3 
       
       
        =
       
       
         f1.call;
    f1.call(f2);
       
       
        //
       
       
        1
       
       
        
    
       
       
        f3.call(f2);
       
       
        //
       
       
        2

这样就不难理解f1.call.call(f2)实现时，f1.call执行过程中call中的this被f2替换成了f2.call();因为f2里没有this的引用所以执行结果是2.

f2.call()
       
       
        //
       
       
        2

需要十分注意的是f1.call是方法，f1是函数对象，这两者在call时是有区别的。

[prototype]: http://www.popo4j.com/tag/prototype.html
[JK]: http://www.cnblogs.com/jkisjk/

发表评论取消回复

表情：

评论列表（有 0 条评论，73人围观）

还没有评论，来说两句吧...

相关阅读

相关 Javascript 中call的使用

Javascript中call的使用自己感觉蛮纠结的，根据文档很好理解，其实很难确定你是否真正的理解。 call 方法应用于：Function 对象调用一个对象的

淩亂°似流年/ 2024年02月17日 15:13/ 0 赞/ 74 阅读

相关 JavaScript中的call、apply、bind

文章目录 call、apply、bind call apply apply和call的使用案例 bind

冷不防/ 2022年10月21日 03:47/ 0 赞/ 208 阅读

相关 Javascript中call的使用

Javascript中call的使用自己感觉蛮纠结的，根据文档很好理解，其实很难确定你是否真正的理解。 call 方法应用于：Function 对象调用一个对象的

怼烎@/ 2022年09月30日 11:54/ 0 赞/ 208 阅读

相关 Javascript中call的使用

Javascript中call的使用自己感觉蛮纠结的，根据文档很好理解，其实很难确定你是否真正的理解。 call 方法应用于：Function 对象调用一个对象的

﹏ヽ暗。殇╰゛Y/ 2022年09月30日 11:54/ 0 赞/ 193 阅读

相关 Javascript中call的使用

Javascript中call的使用自己感觉蛮纠结的，根据文档很好理解，其实很难确定你是否真正的理解。 call 方法应用于：Function 对象调用一个对象的

约定不等于承诺〃/ 2022年08月09日 06:50/ 0 赞/ 192 阅读

相关 Javascript 中“call”的使用

<table style="word-wrap:break-word; empty-cells:show; border-collapse:collapse; table-la

红太狼/ 2022年08月06日 14:14/ 0 赞/ 169 阅读

相关 JavaScript中call()和apply()方法的使用

1 call()方法 call()方法调用一个函数，其具有一个指定的this值和分别地提供参数，其参数需要把实参按照形参的个数传进去，其与apply()方法的区别就是ca

叁歲伎倆/ 2022年06月05日 04:38/ 0 赞/ 277 阅读

相关理解Javascript中的call()

这里面涉及到的不止是call的知识。 call()以及apply()存在的意义是什么呢？目的是改变函数（方法）执行的作用域。这里要声明一点：函数在JavaScript

「爱情、让人受尽委屈。」/ 2022年04月18日 03:58/ 0 赞/ 491 阅读

相关 JavaScript中call、apply、bind、slice的使用

1、参考资料 [http://www.cnblogs.com/coco1s/p/4833199.html][http_www.cnblogs.com_coco1s_p_4

以你之姓@/ 2021年12月13日 05:09/ 0 赞/ 304 阅读

相关 JavaScript 函数 Call的使用

call的语法 function.call(obj,...args) Call的作用是什么呢？通俗来说：我手机没电了，借朋友的手机发个短信，注意是借用，

我就是我/ 2021年07月25日 00:16/ 0 赞/ 391 阅读