javascript中apply()和call()方法

時間 2019-11-10

原文原文鏈接

javascript中apply()和call()方法區別原文連接：http://www.cnblogs.com/fighting_cp/archive/2010/09/20/1831844.htmljavascript

關於javascript中apply()和call()方法的區別

　　若是沒接觸過動態語言,以編譯型語言的思惟方式去理解javaScript將會有種神奇而怪異的感受,由於意識上每每不可能的事恰恰就發生了,甚至以爲不可理喻.若是在學JavaScript這自由而千變萬化的語言過程當中遇到這種感受,那麼就從如今形始,請放下的您的」偏見」,由於這對您來講絕對是一片新大陸,讓JavaScriphtml

好,言歸正傳,先理解JavaScrtipt動態變換運行時上下文特性,這種特性主要就體如今apply, call兩個方法的運用上.java

區分apply,call就一句話,編程

　　foo.call(this, arg1,arg2,arg3) == foo.apply(this, arguments)==this.foo(arg1, arg2, arg3)數組

call, apply都屬於Function.prototype的一個方法,它是JavaScript引擎內在實現的,由於屬於Function.prototype,因此每一個Function對象實例,也就是每一個方法都有call, apply屬性.既然做爲方法的屬性,那它們的使用就固然是針對方法的了.這兩個方法是容易混淆的,由於它們的做用同樣,只是使用方式不一樣.app

相同點:兩個方法產生的做用是徹底同樣的函數

不一樣點:方法傳遞的參數不一樣post

那什麼是方法產生的做用,方法傳遞的參數是什麼呢?ui

咱們就上面的foo.call(this, arg1, arg2, arg3)展開分析.this

foo是一個方法,this是方法執行時上下文相關對象,arg1, arg2, arg3是傳給foo方法的參數.這裏所謂的方法執行時上下文相關對象, 若是有面向對象的編程基礎,那很好理解,就是在類實例化後對象中的this.

在JavaScript中,代碼老是有一個上下文對象,代碼處理該對象以內. 上下文對象是經過this變量來體現的, 這個this變量永遠指向當前代碼所處的對象中.

爲了更好的領會這this是什麼,舉個例子.

　　代碼

題外話:javascript對象全部屬性都是公開的(public),沒私有(private)之說,因此也可直接訪問message屬性

alert(a.message);

可見,A, B類都有一個message屬性(面向對象中所說的成員),A有獲取消息的getMessage方法,B有設置消息的setMessage方法,下面來顯示call的威力.

　　//建立一個B類實例對象

var b = new B();
//給對象a動態指派b的setMessage方法,注意,a自己是沒有這方法的!
b.setMessage.call(a, "a的消息");
//下面將顯示"a的消息"
alert(a.getMessage());
//給對象b動態指派a的getMessage方法,注意,b自己也是沒有這方法的!

這就是動態語言 JavaScript call的威力所在!

簡直是」無中生有」,對象的方法能夠任意指派,而對象自己一直都是沒有這方法的,注意是指派,通俗點就是,方法是借給另外一個對象的調用去完成任務,原理上是方法執行時上下文對象改變了.

因此 b.setMessage.call(a, 「a的消息」); 就等於用a做執行時上下文對象調用b對象的setMessage方法,而這過程當中與b一點關係都沒有, 做用等效於a.setMessage( 「a的消息」);

由於apply與call產生的做用是同樣的,能夠說

call, apply做用就是借用別人的方法來調用,就像調用本身的同樣.

好,理解了call, apply相同處—–做用後,再來看看它們的區別,看過上面例子,相信您大概知道了.

從 b.setMessage.call(a, 「a的消息」) 等效於 a.setMessage( 「a的消息」) 能夠看出, 「a的消息」在call中做爲一個參數傳遞,

那麼在apply中是怎麼表示的呢,直接解釋說不清楚,apply要結合應用場景才一目瞭然.咱們來設計一個應用場景:

       
        01 
        function print(a, b, c, d){ 
       
        02 
        alert(a + b + c + d); 
       
        03 
        } 
       
        04 
        function example(a, b , c , d){ 
       
        05 
        //用call方式借用print,參數顯式打散傳遞 
       
        06 
        print.call(this, a, b, c, d); 
       
        07 
        //用apply方式借用print, 參數做爲一個數組傳遞, 
       
        08 
        //這裏直接用JavaScript方法內自己有的arguments數組 
       
        09 
        print.apply(this, arguments); 
       
        10 
        //或者封裝成數組 
       
        11 
        print.apply(this, [a, b, c, d]); 
       
        12 
        } 
       
        13 
        //下面將顯示」背光腳本」 
       
        14 
        example(」背」 , 「光」 , 「腳」, 「本」);

在這場景中, example方法內,a, b, c, d做爲方法傳遞的參數, 方法分別運用了apply, call去借print方法來調用,

最後一句因爲直接調用example方法, 因此在該方法中的上下文對象this就是window對象.

因此,call, apply方法它們除了第一個參數,即執行時上下文對象相同外,call方法的其它參數將依次傳遞給借用的方法做參數,而apply就兩個參數,第二個參數爲一個數組傳遞.因此能夠說成

call, apply方法區別是,從第二個參數起, call方法參數將依次傳遞給借用的方法做參數, 而apply直接將這些參數放到一個數組中再傳遞, 最後借用方法的參數列表是同樣的.

應用場景:

當參數明確時可用call, 當參數不明確時可用apply給合arguments

 
        1 
        //例 
       
        2 
        print.call(window, 「背」 , 「光」 , 「腳」, 「本」); 
       
        3 
        //foo參數可能爲多個 
       
        4 
        function foo(){ 
       
        5 
        print.apply(window, arguments); 
       
        6 
        }

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.

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

示例5：若是在Class1.call(obj);以後再添加obj.name = 'test1',最後結果會輸入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，這兩個值有時會讓我迷糊。

4.接着看下面的例子

示例7：class1.showTxt.call(class2);之因此會返回class2是由於function(){alert(this.name)}這裏的this被call指定成了class2，變成了alert(class2.name)，因此會返回class2.

alert(class2.showTxt)返回undefined，說明並未定義class2.showTxt方法。

由於併爲給class2添加showTxt方法，因此提示該錯誤。若是在這個調用以前添加Class1.call(class2);這個調用就OK了

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

示例8：這個例子都會返回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函數

在執行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看一下執行結果

接着分析

jsCall在執行的過程當中，return this.apply(oThis,argsNew);裏的this被替換成了f2，11作爲參數傳給了(oThis,argsNew)，變成了f2.apply(11);

返回結果跟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時是有區別的。

原文連接：http://hszy00232.blog.163.com/blog/static/43022753201131835653841/

相關標籤/搜索

每日一句

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