Javascript中call的使用

時間 2019-11-09

原文原文鏈接

Javascript中call的使用本身感受蠻糾結的，根據文檔很好理解，其實很難肯定你是否真正的理解。 call 方法應用於：Function 對象調用一個對象的一個方法，以另外一個對象替換當前對象。 call([thisObj[,arg1[, arg2[, [,.argN]]]]]) 參數：thisObj 可選項。將被用做當前對象的對象。 arg1, arg2, , argN 可選項。將被傳遞方法參數序列。說明： call 方法能夠用來代替另外一個對象調用一個方法。call 方法可將一個函數的對象上下文從初始的上下文改變爲由 thisObj 指定的新對象。若是沒有提供 thisObj 參數，那麼 Global 對象被用做 thisObj。app

最基本的理解
自定義一個類，該類有一個方法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)}
```
再看一個稍微深刻的理解
建立Class1的實例，讓這個實例調用showTxt方法返回這個實例的name值，由於這個實現沒有name值因此返回undefine。this
```
function Class1(){
    this.showTxt = function(){alert(this.name)}
}
var class1 = new Class1();
class1.showTxt();//undefined
alert(class1.showTxt);//function(){alert(this.name)}
```

下面就給Class1添加個name值，這時class1再調用showTxt方法，會返回class1，這是由於給類添加了name值，因此實例的name也由undefine變成了class1.prototype

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

Class1.call(obj) 這個操做把Class1中的this.name,this.showTxt裏的this替換成了obj，因此就變成了obj.name='class1'，因此obj.showTxt在執行時返回class1。code

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

若是在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的都是一個對象的實例，接下來的案例把對象的實例直接換成函數，看看執行結果會發生哪些變化ip

把call方法的第一參數由實例換成函數看看會怎麼樣
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
```
接着看下面的例子
class1.showTxt.call(class2);之因此會返回class2是由於function(){alert(this.name)}這裏的this被call指定成了class2，變成了alert(class2.name)，因此會返回class2。
alert(class2.showTxt)返回undefined，說明並未定義class2.showTxt方法。io
```
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();//class1function

這個例子都會返回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

在使用call時若是調用函數裏沒有this會怎麼樣
```
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
```

不錯，接下來再理解一個怪異的形式

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)如何執行。
引用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],22,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時是有區別的。

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。