Javascript中call的使用自己感覺蠻糾結(jié)的，根據(jù)文檔很好理解，其實很難確定你是否真正的理解。

call 方法
應(yīng)用于：Function 對象
調(diào)用一個對象的一個方法，以另一個對象替換當(dāng)前對象。
call([thisObj[,arg1[, arg2[,? ?[,.argN]]]]])
參數(shù)：
thisObj
可選項。將被用作當(dāng)前對象的對象。
arg1, arg2, , argN
可選項。將被傳遞方法參數(shù)序列。
說明：
call 方法可以用來代替另一個對象調(diào)用一個方法。call 方法可將一個函數(shù)的對象上下文從初始的上下文改變?yōu)橛?thisObj 指定的新對象。如果沒有提供 thisObj 參數(shù)，那么 Global 對象被用作 thisObj。

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

自定義一個類，該類有一個方法showTxt，用來顯示當(dāng)前對象的name值。

創(chuàng)建一個對象，并且該對象的name值等于test1。

使用call方法，使新創(chuàng)建的對象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：創(chuàng)建Class1的實例，讓這個實例調(diào)用showTxt方法返回這個實例的name值，因為這個實現(xiàn)沒有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再調(diào)用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在執(zhí)行時返回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',最后結(jié)果會輸入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的都是一個對象的實例，接下來的案例把對象的實例直接換成函數(shù)，看看執(zhí)行結(jié)果會發(fā)生哪些變化

3.把call方法的第一參數(shù)由實例換成函數(shù)看看會怎么

示例6：Class2是一個function對象的引用,在執(zhí)行Class1.call(Class2)時this.showTxt里的this被替換成了Class2。這樣Class2就有了showTxt方法，Class2.showTxt()執(zhí)行時會返回Class2.name的值，因為Class2并未定義name值，所以會返回undefined。

Class2函數(shù)里的this.name是由Class2創(chuàng)建實例的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方法，所以提示該錯誤。如果在這個調(diào)用之前添加Class1.call(class2);這個調(diào)用就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時如果調(diào)用函數(shù)里沒有this會怎么樣

示例9：

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

結(jié)果返回4，add.call(sub,3,1)在執(zhí)行過程中，sub做為add函數(shù)中this的替代品出現(xiàn)，但是因為add里沒有用到this，所以sub函數(shù)直接忽略，所以結(jié)果是4。

所以實際執(zhí)行如下：返回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呢，為了方便理解進(jìn)行一下等效變化為f1.call.call(f2)，這時會發(fā)現(xiàn)實際上是f1.call方法call調(diào)用了f2，那f1怎么又會有call方法呢？call, apply都屬于Function.prototype的一個方法,它是JavaScript引擎內(nèi)在實現(xiàn)的,因為屬于Function.prototype,所以每個Function對象實例,也就是每個方法都有call, apply屬性。

在理解f1.call.call(f2)時我們首先要知道call方法到底是如何執(zhí)行的，這樣才能f1.call.call(f2)如何執(zhí)行。

示例11：

引用JK寫的一個用apply實現(xiàn)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.

接下來構(gòu)建兩個函數(shù)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

執(zhí)行結(jié)果發(fā)現(xiàn)[object Window]被替換成f2函數(shù)

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

在執(zhí)行f1.jsCall.jsCall(f2,11);時返回11,,f2，為什么會返回這個結(jié)果，重點來了:)

f1.jsCall方法：

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

所以f1.jsCall.jsCall可以替換成jsCall.jsCall看一下執(zhí)行結(jié)果

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在執(zhí)行的過程中，return this.apply(oThis,argsNew);里的this被替換成了f2，11做為參數(shù)傳給了(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

返回結(jié)果跟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)實現(xiàn)時，f1.call執(zhí)行過程中call中的this被f2替換成了f2.call();因為f2里沒有this的引用所以執(zhí)行結(jié)果是2.

f2.call()//2

需要十分注意的是f1.call是方法，f1是函數(shù)對象，這兩者在call時是有區(qū)別的。

轉(zhuǎn)載于:https://www.cnblogs.com/guopei/archive/2011/04/17/2019045.html

總結(jié)

以上是生活随笔為你收集整理的Javascript中call的使用的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。