|
|
對象: 一個無序?qū)傩缘募?，這些屬性的值為簡單數(shù)值類型、對象或者函數(shù)。同上，這里的對象并不特指全局對象Object。
函數(shù): 函數(shù)是對象的一種，實現(xiàn)上內(nèi)部屬性[[Class]]值為"Function"，表明它是函數(shù)類型，除了對象的內(nèi)部屬性方法外，還有 [[Construct]]、[[Call]]、[[Scope]]等內(nèi)部屬性。函數(shù)作為函數(shù)調(diào)用與構(gòu)造器(使用new關(guān)鍵字創(chuàng)建實例對象)的處理機制不 一樣(Function對象除外)，內(nèi)部方法[[Construct]]用于實現(xiàn)作為構(gòu)造器的邏輯，方法[[Call]]實現(xiàn)作為函數(shù)調(diào)用的邏輯。同上， 這里的函數(shù)并不特指全局對象Function。
函數(shù)在JS這個Prototype語言中可以看作是面向?qū)ο笳Z言的類，可以用它來構(gòu)造對象實例。既然函數(shù)可以看作是類，所以每一個函數(shù)可以看作是一種擴展數(shù)據(jù)類型。
內(nèi)置數(shù)據(jù)類型(內(nèi)置對象)
Function: 函數(shù)類型的用戶接口。
Object: 對象類型的用戶接口。
Boolean, Number, String: 分別為這三種簡單數(shù)值類型的對象包裝器，對象包裝在概念上有點類似C#中的Box/Unbox。
Date, Array, RegExp: 可以把它們看作是幾種內(nèi)置的擴展數(shù)據(jù)類型。
首先，F(xiàn)unction, Object, Boolean, Number, String, Date, Array, RegExp等都是JavaScript語言的內(nèi)置對象，它們都可以看作是函數(shù)的派生類型，例如Number instanceof Function為true，Number instanceof Object為true。在這個意義上，可以將它們跟用戶定義的函數(shù)等同看待。
其次，它們各自可以代表一種數(shù)據(jù)類型，由JS引擎用native code或內(nèi)置的JS代碼實現(xiàn)，是暴露給開發(fā)者對這些內(nèi)置數(shù)據(jù)類型進(jìn)行操作的接口。在這個意義上，它們都是一種抽象的概念，后面隱藏了具體的實現(xiàn)機制。
在每一個提到Number, Function等單詞的地方，應(yīng)該迅速的在思維中將它們實例化為上面的兩種情況之一。
數(shù)據(jù)類型實現(xiàn)模型描述
Build-in *** data structure: 指JS內(nèi)部用于實現(xiàn)***類型的數(shù)據(jù)結(jié)構(gòu)，這些結(jié)構(gòu)我們基本上無法直接操作。
Build-in *** object: 指JS內(nèi)置的Number, String, Boolean等這些對象，這是JS將內(nèi)部實現(xiàn)的數(shù)據(jù)類型暴露給開發(fā)者使用的接口。
Build-in *** constructor: 指JS內(nèi)置的一些構(gòu)造器，用來構(gòu)造相應(yīng)類型的對象實例。它們被包裝成函數(shù)對象暴露出來，例如我們可以使用下面的方法訪問到這些函數(shù)對象:
//Passed in FF2.0, IE7, Opera9.25, Safari3.0.4
//access the build-in number constructor
var number = new Number(123);
var numConstructor1 = number.constructor; //or
var numConstructor2 = new Object(123).constructor;
//both numConstructor1 and numConstructor2 are the build-in Number constructor
numConstructor1 == numConstructor2 //result: true
//access the build-in object constructor
var objConstructor1 = {}.constructor; //or
var objConstructor2 = new Object().constructor;
//both objConstructor1 and objConstructor2 are the build-in Object constructor
objConstructor1==objConstructor2 //result: true
具體實現(xiàn)上，上圖中橫向之間可能也存在關(guān)聯(lián)，例如對于build-in data structure和constructor，F(xiàn)unction、 Date、 Array、 RegExp等都可以繼承Object的結(jié)構(gòu)而實現(xiàn)，但這是具體實現(xiàn)相關(guān)的事情了。
關(guān)于簡單數(shù)值類型的對象化
這是一個細(xì)微的地方，下面描述對于Boolean, String和Number這三種簡單數(shù)值類型都適用，以Number為例說明。
JS規(guī)范要求: 使用var num1=123;這樣的代碼，直接返回基本數(shù)據(jù)類型，就是說返回的對象不是派生自Number和Object類型，用num1 instanceof Object測試為false；使用new關(guān)鍵字創(chuàng)建則返回Number類型，例如var num2=new Number(123); num2 instanceof Number為true。
將Number當(dāng)作函數(shù)調(diào)用，返回結(jié)果會轉(zhuǎn)換成簡單數(shù)值類型。下面是測試代碼:
//Passed in FF2.0, IE7, Opera9.25, Safari3.0.4
var num1 = new Number(123); //num1 derived from Number & Object
num1 instanceof Number //result: true
num1 instanceof Object //result: true
//convert the num1 from Number type to primitive type, so it's no longer an instance of Number or Object
num1 = Number(num1);
num1 instanceof Number //result: false
num1 instanceof Object //result: false
var num2 = 123; //num2 is a primitive type
num2 instanceof Number //result: false
num2 instanceof Object //result: false雖然我們得到了一個簡單數(shù)值類型，但它看起來仍然是一個JS Object對象，具有Object以及相應(yīng)類型的所有屬性和方法，使用上基本沒有差別，唯一不同之處是instanceof的測試結(jié)果。
Prototype繼承
Prototype
每個對象都有一個[[Prototype]]的內(nèi)部屬性，它的值為null或者另外一個對象。函數(shù)對象都有一個顯示的prototype屬性，它并不是內(nèi) 部[[Prototype]]屬性。不同的JS引擎實現(xiàn)者可以將內(nèi)部[[Prototype]]屬性命名為任何名字，并且設(shè)置它的可見性，只在JS引擎內(nèi) 部使用。雖然無法在JS代碼中訪問到內(nèi)部[[Prototype]](FireFox中可以，名字為__proto__因為Mozilla將它公開了)， 但可以使用對象的isPrototypeOf()方法進(jìn)行測試，注意這個方法會在整個Prototype鏈上進(jìn)行判斷。
使用obj.propName訪問一個對象的屬性時，按照下面的步驟進(jìn)行處理(假設(shè)obj的內(nèi)部[[Prototype]]屬性名為__proto__):
1. 如果obj存在propName屬性，返回屬性的值，否則
2. 如果obj.__proto__為null，返回undefined，否則
3. 返回obj.__proto__.propName
調(diào)用對象的方法跟訪問屬性搜索過程一樣，因為方法的函數(shù)對象就是對象的一個屬性值。
提示: 上面步驟中隱含了一個遞歸過程，步驟3中obj.__proto__是另外一個對象，同樣將采用1, 2, 3這樣的步驟來搜索propName屬性。
例如下圖所示，object1將具備屬性prop1, prop2, prop3以及方法fn1, fn2, fn3。圖中虛線箭頭表示prototype鏈。
這就是基于Prototype的繼承和共享。其中object1的方法fn2來自object2，概念上即object2重寫了object3的方法fn2。
JavaScript對象應(yīng)當(dāng)都通過prototype鏈關(guān)聯(lián)起來，最頂層是Object，即對象都派生自O(shè)bject類型。
類似C++等面向?qū)ο笳Z言用類(被抽象了的類型)來承載方法，用對象(實例化對象)承載屬性，Prototype語言只用實例化的對象來承載方法和屬性。本質(zhì)區(qū)別是前者基于內(nèi)存結(jié)構(gòu)的描述來實現(xiàn)繼承，后者基于具體的內(nèi)存塊實現(xiàn)。
對象創(chuàng)建過程
JS中只有函數(shù)對象具備類的概念，因此要創(chuàng)建一個對象，必須使用函數(shù)對象。函數(shù)對象內(nèi)部有[[Construct]]方法和[[Call]]方法， [[Construct]]用于構(gòu)造對象，[[Call]]用于函數(shù)調(diào)用，只有使用new操作符時才觸發(fā)[[Construct]]邏輯。
var obj=new Object(); 是使用內(nèi)置的Object這個函數(shù)對象創(chuàng)建實例化對象obj。var obj={};和var obj=[];這種代碼將由JS引擎觸發(fā)Object和Array的構(gòu)造過程。function fn(){}; var myObj=new fn();是使用用戶定義的類型創(chuàng)建實例化對象。
new Fn(args)的創(chuàng)建過程如下(即函數(shù)對象的[[Construct]]方法處理邏輯，對象的創(chuàng)建過程)。另外函數(shù)對象本身的創(chuàng)建過程(指定義函數(shù)或者用Function創(chuàng)建一個函數(shù)對象等方式)雖然也使用了下面的處理邏輯，但有特殊的地方，后面再描述。
1. 創(chuàng)建一個build-in object對象obj并初始化
2. 如果Fn.prototype是Object類型，則將obj的內(nèi)部[[Prototype]]設(shè)置為Fn.prototype，否則obj的[[Prototype]]將為其初始化值(即Object.prototype)
3. 將obj作為this，使用args參數(shù)調(diào)用Fn的內(nèi)部[[Call]]方法
3.1 內(nèi)部[[Call]]方法創(chuàng)建當(dāng)前執(zhí)行上下文
3.2 調(diào)用F的函數(shù)體
3.3 銷毀當(dāng)前的執(zhí)行上下文
3.4 返回F函數(shù)體的返回值，如果F的函數(shù)體沒有返回值則返回undefined
4. 如果[[Call]]的返回值是Object類型，則返回這個值，否則返回obj
注意步驟2中， prototype指對象顯示的prototype屬性，而[[Prototype]]則代表對象內(nèi)部Prototype屬性(隱式的)。
構(gòu)成對象Prototype鏈的是內(nèi)部隱式的[[Prototype]]，而并非對象顯示的prototype屬性。顯示的prototype只有在函數(shù) 對象上才有意義，從上面的創(chuàng)建過程可以看到，函數(shù)的prototype被賦給派生對象隱式[[Prototype]]屬性，這樣根據(jù)Prototype規(guī) 則，派生對象和函數(shù)的prototype對象之間才存在屬性、方法的繼承/共享關(guān)系。
用代碼來做一些驗證:
//Passed in FF2.0, IE7, Opera9.25, Safari3.0.4
function fn(){}
//the value of implicit [[Prototype]] property of those objects derived from fn will be assigned to fn.prototype
fn.prototype={ attr1:"aaa", attr2:"bbb"};
var obj=new fn();
document.write(obj.attr1 + "<br />"); //result: aaa
document.write(obj.attr2 + "<br />"); //result: bbb
document.write(obj instanceof fn); //result: true
document.write("<br />");
//I change the prototype of fn here, so by the algorithm of Prototype the obj is no longer the instance of fn,
//but this won't affect the obj and its [[Prototype]] property, and the obj still has attr1 and attr2 properties
fn.prototype={};
document.write(obj.attr1 + "<br />"); //result: aaa
document.write(obj.attr2 + "<br />"); //result: bbb
document.write(obj instanceof fn); //result: false關(guān)于創(chuàng)建過程返回值的驗證:
//Passed in FF2.0, IE7, Opera9.25, Safari3.0.4
function fn(){
//according to step 4 described above,
//the new fn() operation will return the object { attr1: 111, attr2: 222 }, it's not an instance of fn!
return { attr1: 111, attr2: 222 };
}
fn.prototype={ attr1:"aaa", attr2:"bbb"};
var obj=new fn();
document.write(obj.attr1 + "<br />"); //result: 111
document.write(obj.attr2 + "<br />"); //result: 222
document.write(obj instanceof fn); //result: false
做個練習(xí)
經(jīng)過上面的理解應(yīng)，請寫出下面這幅圖的實現(xiàn)代碼。圖中CF是一個函數(shù)，Cfp是CF的prototype對象，cf1, cf2, cf3, cf4, cf5都是CF的實例對象。虛線箭頭表示隱式Prototype關(guān)系，實線箭頭表示顯示prototype關(guān)系。
供參考的實現(xiàn)方案:
//Passed in FF2.0, IE7, Opera9.25, Safari3.0.4
function CF(q1, q2){
this.q1=q1;
this.q2=q2;
}
CF.P1="P1 in CF";
CF.P2="P2 in CF";
function Cfp(){
this.CFP1="CFP1 in Cfp";
}
CF.prototype=new Cfp();
var cf1=new CF("aaa", "bbb");
document.write(cf1.CFP1 + "<br />"); //result: CFP1 in Cfp
document.write(cf1.q1 + "<br />"); //result: aaa
document.write(cf1.q2 + "<br />"); //result: bbb
本地屬性與繼承屬性
對象通過隱式Prototype鏈能夠?qū)崿F(xiàn)屬性和方法的繼承，但prototype也是一個普通對象，就是說它是一個普通的實例化的對象，而不是純粹抽象的數(shù)據(jù)結(jié)構(gòu)描述。所以就有了這個本地屬性與繼承屬性的問題。
首先看一下設(shè)置對象屬性時的處理過程。JS定義了一組attribute，用來描述對象的屬性property，以表明屬性property是否可以在JavaScript代碼中設(shè)值、被for in枚舉等。
obj.propName=value的賦值語句處理步驟如下:
1. 如果propName的attribute設(shè)置為不能設(shè)值，則返回
2. 如果obj.propName不存在，則為obj創(chuàng)建一個屬性，名稱為propName
3. 將obj.propName的值設(shè)為value
可以看到，設(shè)值過程并不會考慮Prototype鏈，道理很明顯，obj的內(nèi)部[[Prototype]]是一個實例化的對象，它不僅僅向obj共享屬性，還可能向其它對象共享屬性，修改它可能影響其它對象。
用上面CF, Cfp的示例來說明，實例對象cf1具有本地屬性q1, q2以及繼承屬性CFP1，如果執(zhí)行cf1.CFP1=""，那么cf1就具有本地屬性CFP1了，測試結(jié)果如下:
//Passed in FF2.0, IE7, Opera9.25, Safari3.0.4
var cf1=new CF("aaa", "bbb");
var cf2=new CF(111, 222);
document.write(cf1.CFP1 + "<br />"); //result: CFP1 in Cfp
document.write(cf2.CFP1 + "<br />"); //result: CFP1 in Cfp
//it will result in a local property in cf1
cf1.CFP1="new value for cf1";
//changes on CF.prototype.CFP1 will affect cf2 but not cf1, because there's already a local property with
//the name CFP1 in cf1, but no such one in cf2
CF.prototype.CFP1="new value for Cfp";
document.write(cf1.CFP1 + "<br />"); //result: new value for cf1
document.write(cf2.CFP1 + "<br />"); //result: new value for Cfp
語義上的混亂?
還是使用上面CF, Cfp示例的場景。
根據(jù)Prototype的機制，我們可以說對象cf1, cf2等都繼承了對象Cfp的屬性和方法，所以應(yīng)該說他們之間存在繼承關(guān)系。屬性的繼承/共享是沿著隱式Prototype鏈作用的，所以繼承關(guān)系也應(yīng)當(dāng)理解為沿著這個鏈。
我們再看instanceOf操作，只有cf1 instanceOf CF才成立，我們說cf1是CF的實例對象，CF充當(dāng)了類的角色，而不會說cf1是Cfp的實例對象，這樣我們應(yīng)當(dāng)說cf1繼承自CF? 但CF充當(dāng)?shù)闹皇且粋€第三方工廠的角色，它跟cf1之間并沒有屬性繼承這個關(guān)系。
把CF, Cfp看作一個整體來理解也同樣牽強。
Prototype就是Prototype，沒有必要強把JavaScript與面向?qū)ο蟾拍罱Y(jié)合起來， JavaScript只具備有限的面向?qū)ο竽芰?，從另外的角度我們可以把它看成函?shù)語言、動態(tài)語言，所以它是吸收了多種語言特性的精簡版。
對象模型
Where are we?
1. 了解了JavaScript的數(shù)據(jù)類型，清楚了象Number這樣的系統(tǒng)內(nèi)置對象具有多重身份: a)它們本身是一個函數(shù)對象，只是由引擎內(nèi)部實現(xiàn)而已，b)它們代表一種數(shù)據(jù)類型，我們可以用它們定義、操作相應(yīng)類型的數(shù)據(jù)，c)在它們背后隱藏了引擎的 內(nèi)部實現(xiàn)機制，例如內(nèi)部的數(shù)據(jù)結(jié)構(gòu)、各種被包裝成了JavaScript對象的構(gòu)造器等。
2. 了解了Prototype機制，知道對象是如何通過它們繼承屬性和方法，知道了在創(chuàng)建對象過程中JS引擎內(nèi)部是如何設(shè)置Prototype關(guān)系的。
接下來對用戶自定義函數(shù)對象本身的創(chuàng)建過程進(jìn)行了解之后，我們就可以對JavaScript的對象模型來一個整體性的overview了。
函數(shù)對象創(chuàng)建過程
JavaScript代碼中定義函數(shù)，或者調(diào)用Function創(chuàng)建函數(shù)時，最終都會以類似這樣的形式調(diào)用Function函數(shù):var newFun=Function(funArgs, funBody); 。創(chuàng)建函數(shù)對象的主要步驟如下:
1. 創(chuàng)建一個build-in object對象fn
2. 將fn的內(nèi)部[[Prototype]]設(shè)為Function.prototype
3. 設(shè)置內(nèi)部的[[Call]]屬性，它是內(nèi)部實現(xiàn)的一個方法，處理邏輯參考對象創(chuàng)建過程的步驟3
4. 設(shè)置內(nèi)部的[[Construct]]屬性，它是內(nèi)部實現(xiàn)的一個方法，處理邏輯參考對象創(chuàng)建過程的步驟1,2,3,4
5. 設(shè)置fn.length為funArgs.length，如果函數(shù)沒有參數(shù)，則將fn.length設(shè)置為0
6. 使用new Object()同樣的邏輯創(chuàng)建一個Object對象fnProto
7. 將fnProto.constructor設(shè)為fn
8. 將fn.prototype設(shè)為fnProto
9. 返回fn
步驟1跟步驟6的區(qū)別為，步驟1只是創(chuàng)建內(nèi)部用來實現(xiàn)Object對象的數(shù)據(jù)結(jié)構(gòu)(build-in object structure)，并完成內(nèi)部必要的初始化工作，但它的[[Prototype]]、[[Call]]、[[Construct]]等屬性應(yīng)當(dāng)為 null或者內(nèi)部初始化值，即我們可以理解為不指向任何對象(對[[Prototype]]這樣的屬性而言)，或者不包含任何處理(對[[Call]]、 [[Construct]]這樣的方法而言)。步驟6則將按照前面描述的對象創(chuàng)建過程創(chuàng)建一個新的對象，它的[[Prototype]]等被設(shè)置了。
從上面的處理步驟可以了解，任何時候我們定義一個函數(shù)，它的prototype是一個Object實例，這樣默認(rèn)情況下我們創(chuàng)建自定義函數(shù)的實例對象時，它們的Prototype鏈將指向Object.prototype。
另外，F(xiàn)unction一個特殊的地方，是它的[[Call]]和[[Construct]]處理邏輯一樣。
JavaScript對象模型
紅色虛線表示隱式Prototype鏈。
這張對象模型圖中包含了太多東西，不少地方需要仔細(xì)體會，可以寫些測試代碼進(jìn)行驗證。徹底理解了這張圖，對JavaScript語言的了解也就差不多了。下面是一些補充說明:
1. 圖中有好幾個地方提到build-in Function constructor，這是同一個對象，可以測試驗證:
//Passed in FF2.0, IE7, Opera9.25, Safari3.0.4
Function==Function.constructor //result: true
Function==Function.prototype.constructor //result: true
Function==Object.constructor //result: true
//Function also equals to Number.constructor, String.constructor, Array.constructor, RegExp.constructor, etc.
function fn(){}
Function==fn.constructor //result: true這說明了幾個問題: Function指向系統(tǒng)內(nèi)置的函數(shù)構(gòu)造器(build-in Function constructor)；Function具有自舉性；系統(tǒng)中所有函數(shù)都是由Function構(gòu)造。
2. 左下角的obj1, obj2...objn范指用類似這樣的代碼創(chuàng)建的對象: function fn1(){}; var obj1=new fn1();
這些對象沒有本地constructor方法，但它們將從Prototype鏈上得到一個繼承的constructor方法，即fn.prototype.constructor，從函數(shù)對象的構(gòu)造過程可以知道，它就是fn本身了。
右下角的obj1, obj2...objn范指用類似這樣的代碼創(chuàng)建的對象: var obj1=new Object();或var obj1={};或var obj1=new Number(123);或obj1=//w+/;等等。所以這些對象Prototype鏈的指向、從Prototype鏈繼承而來的 constructor的值(指它們的constructor是build-in Number constructor還是build-in Object constructor等)等依賴于具體的對象類型。另外注意的是，var obj=new Object(123);這樣創(chuàng)建的對象，它的類型仍然是Number，即同樣需要根據(jù)參數(shù)值的類型來確定。
同樣它們也沒有本地constructor，而是從Prototype鏈上獲得繼承的constructor方法，即build-in *** constructor，具體是哪一個由數(shù)據(jù)類型確定。
3. 關(guān)于圖中Prototype鏈的補充說明:
Object.prototype是整個鏈的終結(jié)點，它的內(nèi)部[[Prototype]]為null。
所有函數(shù)的Prototype鏈都指向Function.prototype。
Function的Prototype鏈指向Function.prototype，這是規(guī)范要求的，因為設(shè)計者將Function設(shè)計為具有自舉性。 Function的Prototype鏈這樣設(shè)計之后，F(xiàn)unction.constructor==Function, Function instanceOf Function都為true。另外Function已經(jīng)是最頂層的構(gòu)造器，但Function本身也是一個函數(shù)對象，它必然是由某個東西創(chuàng)建出來的，這 樣自舉在語義上合情合理。
Function.prototype的Prototype鏈指向Object.prototype，這也是規(guī)范強制要求的。首先 Function.prototype是Function的一個實例對象(typeof Function.prototype可以知道它是一個Function，instanceOf無法通過測試，因為Prototype鏈在內(nèi)部被額外設(shè)置 了），所以按照Prototype的規(guī)則，F(xiàn)unction.prototype的內(nèi)部[[Prototype]]值應(yīng)當(dāng)為 Function.prototype這個對象，即它的Prototype鏈指向自己本身。這樣一方面在Prototype鏈上造成一個死循環(huán)，另一方面 它本身成為了一個終結(jié)點，結(jié)果就是所有函數(shù)對象將不是派生自O(shè)bject了。加上這個強制要求之后，Prototype鏈只有唯一的一個終結(jié)點。
4. 因為Function.prototype是一個函數(shù)對象，所以它應(yīng)當(dāng)具有顯示的prototype屬性，即 Function.prototype.prototype，但只有FireFox中可以訪問到，IE、Opera、Safari都無法訪問。所以圖中用 了個表示不存在的符號。
5. 用戶自定義函數(shù)(user defined functions)默認(rèn)情況下[[Prototype]]值是Object.prototype，即它的隱式Prototype鏈指向 Object.prototype，所以圖中就這樣表示了，但并不代表總是這樣，當(dāng)用戶設(shè)置了自定義函數(shù)的prototype屬性之后，情況就不同了。
執(zhí)行模型
執(zhí)行上下文(Execution Context)簡介
JavaScript代碼運行的地方都存在執(zhí)行上下文，它是一個概念，一種機制，用來完成JavaScript運行時作用域、生存期等方面的處理。執(zhí)行上 下文包括Variable Object、Variable Instatiation、Scope/Scope Chain等概念，在不同的場景/執(zhí)行環(huán)境下，處理上存在一些差異，下面先對這些場景進(jìn)行說明。
函數(shù)對象分為用戶自定義函數(shù)對象和系統(tǒng)內(nèi)置函數(shù)對象，對于用戶自定義函數(shù)對象將按照下面描述的機制進(jìn)行處理，但內(nèi)置函數(shù)對象與具體實現(xiàn)相關(guān)，ECMA規(guī)范對它們執(zhí)行上下文的處理沒有要求，即它們基本不適合本節(jié)描述的內(nèi)容。
執(zhí)行的JavaScript代碼分三種類型，后面會對這三種類型處理上不同的地方進(jìn)行說明:
1. Global Code，即全局的、不在任何函數(shù)里面的代碼，例如一個js文件、嵌入在HTML頁面中的js代碼等。
2. Eval Code，即使用eval()函數(shù)動態(tài)執(zhí)行的JS代碼。
3. Function Code，即用戶自定義函數(shù)中的函數(shù)體JS代碼。
基本原理
在用戶自定義函數(shù)中，可以傳入?yún)?shù)、在函數(shù)中定義局部變量，函數(shù)體代碼可以使用這些入?yún)?、局部變量。背后的機制是什么樣呢？
當(dāng)JS執(zhí)行流進(jìn)入函數(shù)時，JavaScript引擎在內(nèi)部創(chuàng)建一個對象，叫做Variable Object。對應(yīng)函數(shù)的每一個參數(shù)，在Variable Object上添加一個屬性，屬性的名字、值與參數(shù)的名字、值相同。函數(shù)中每聲明一個變量，也會在Variable Object上添加一個屬性，名字就是變量名，因此為變量賦值就是給Variable Object對應(yīng)的屬性賦值。在函數(shù)中訪問參數(shù)或者局部變量時，就是在variable Object上搜索相應(yīng)的屬性，返回其值。
一般情況下Variable Object是一個內(nèi)部對象，JS代碼中無法直接訪問。規(guī)范中對其實現(xiàn)方式也不做要求，因此它可能只是引擎內(nèi)部的一種數(shù)據(jù)結(jié)構(gòu)。
大致處理方式就這樣，但作用域的概念不只這么簡單，例如函數(shù)體中可以使用全局變量、函數(shù)嵌套定義時情況更復(fù)雜點。這些情況下怎樣處理？ JavaScript引擎將不同執(zhí)行位置上的Variable Object按照規(guī)則構(gòu)建一個鏈表，在訪問一個變量時，先在鏈表的第一個Variable Object上查找，如果沒有找到則繼續(xù)在第二個Variable Object上查找，直到搜索結(jié)束。這就是Scope/Scope Chain的大致概念。
下面是各個方面詳細(xì)的處理。
Global Object
JavaScript的運行環(huán)境都必須存在一個唯一的全局對象-Global Object，例如HTML中的window對象。Global Object是一個宿主對象，除了作為JavaScript運行時的全局容器應(yīng)具備的職責(zé)外，ECMA規(guī)范對它沒有額外要求。它包Math、 String、Date、parseInt等JavaScript中內(nèi)置的全局對象、函數(shù)(都作為Global Object的屬性)，還可以包含其它宿主環(huán)境需要的一些屬性。
Variable Object
上面簡述了Variable Object的基本概念。創(chuàng)建Variable Object，將參數(shù)、局部變量設(shè)置為Variable Object屬性的處理過程叫做Variable Instatiation-變量實例化，后面結(jié)合Scope Chain再進(jìn)行詳細(xì)說明。
Global Code
Variable Object就是Global Object，這是Variable Object唯一特殊的地方(指它是內(nèi)部的無法訪問的對象而言)。
var globalVariable = "WWW";
document.write(window.globalVariable); //result: WWW上面代碼在Global Code方式下運行，根據(jù)對Variable Object的處理，定義變量globalVariable時就會在Global Object(即window)對象上添加這個屬性，所以輸出是WWW這個值。
Function Code
Variable Object也叫做Activation Object(因為有一些差異存在，所以規(guī)范中重新取一個名字以示區(qū)別，Global Code/Eval Code中叫Variable Object，F(xiàn)unction Code中就叫做Activation Object)。
每次進(jìn)入函數(shù)執(zhí)行都會創(chuàng)建一個新的Activation Object對象，然后創(chuàng)建一個arguments對象并設(shè)置為Activation Object的屬性，再進(jìn)行Variable Instantiation處理。
在退出函數(shù)時，Activation Object會被丟棄(并不是內(nèi)存釋放，只是可以被垃圾回收了)。
附arguments對象的屬性:
length: 為實際傳入?yún)?shù)的個數(shù)。注意，參考函數(shù)對象創(chuàng)建過程，函數(shù)對象上的length為函數(shù)定義時要求的參數(shù)個數(shù)；
callee: 為執(zhí)行的函數(shù)對象本身。目的是使函數(shù)對象能夠引用自己，例如需要遞歸調(diào)用的地方。
function fnName(...) { ... }這樣定義函數(shù)，它的遞歸調(diào)用可以在函數(shù)體內(nèi)使用fnName完成。var fn=function(...) { ... }這樣定義匿名函數(shù)，在函數(shù)體內(nèi)無法使用名字引用自己，通過arguments.callee就可以引用自己而實現(xiàn)遞歸調(diào)用。
參數(shù)列表: 調(diào)用者實際傳入的參數(shù)列表。這個參數(shù)列表提供一個使用索引訪問實際參數(shù)的方法。Variable Instantiation處理時會在Activation Object對象上添加屬性，前提是函數(shù)聲明時有指定參數(shù)列表。如果函數(shù)聲明中不給出參數(shù)列表，或者實際調(diào)用參數(shù)個數(shù)與聲明時的不一樣，可以通過 arguments訪問各個參數(shù)。
arguments中的參數(shù)列表與Activation Object上的參數(shù)屬性引用的是相同的參數(shù)對象(如果修改，在兩處都會反映出來)。規(guī)范并不要求arguments是一個數(shù)組對象，下面是一個測試:
//Passed in FF2.0, IE7, Opera9.25, Safari3.0.4
var argumentsLike = { 0: "aaa", 1: 222, 2: "WWW", length: 3, callee: function() { } };
document.write(argumentsLike[2] + "<br />"); //result: WWW
document.write(argumentsLike[1] + "<br />"); //result: 222
//convert the argumentsLike to an Array object, just as we can do this for the arguments property
var array = [].slice.apply(argumentsLike);
document.write(array instanceof Array); //result: true
document.write("<br />");
document.write(array.reverse().join("|")); //result: WWW|222|aaa
Eval Code
Variable Object就是調(diào)用eval時當(dāng)前執(zhí)行上下文中的Variable Object。在Global Code中調(diào)用eval函數(shù)，它的Variable Object就是Global Object；在函數(shù)中調(diào)用eval，它的Variable Object就是函數(shù)的Activation Object。
//Passed in FF2.0, IE7, Opera9.25, Safari3.0.4
function fn(arg){
var innerVar = "variable in function";
eval(' /
var evalVar = "variable in eval"; /
document.write(arg + "<br />"); /
document.write(innerVar + "<br />"); /
');
document.write(evalVar);
}
fn("arguments for function");輸出結(jié)果是:
arguments for function
variable in function
variable in eval
說明: eval調(diào)用中可以訪問函數(shù)fn的參數(shù)、局部變量；在eval中定義的局部變量在函數(shù)fn中也可以訪問，因為它們的Varible Object是同一個對象。
Scope/Scope Chain
首先Scope Chain是一個類似鏈表/堆棧的結(jié)構(gòu)，里面每個元素基本都是Variable Object/Activation Object。
其次存在執(zhí)行上下文的地方都有當(dāng)前Scope Chain，可以理解為Scope Chain就是執(zhí)行上下文的具體表現(xiàn)形式。
Global Code
Scope Chain只包含一個對象，即Global Object。在開始JavaScript代碼的執(zhí)行之前，引擎會創(chuàng)建好這個Scope Chain結(jié)構(gòu)。
Function Code
函數(shù)對象在內(nèi)部都有一個[[Scope]]屬性，用來記錄該函數(shù)所處位置的Scope Chain。
創(chuàng)建函數(shù)對象時，引擎會將當(dāng)前執(zhí)行環(huán)境的Scope Chain傳給Function的[[Construct]]方法。[[Construct]]會創(chuàng)建一個新的Scope Chain，內(nèi)容與傳入的Scope Chain完全一樣，并賦給被創(chuàng)建函數(shù)的內(nèi)部[[Scope]]屬性。在前面函數(shù)對象創(chuàng)建過程一節(jié)中，這個處理位于步驟4和5之間。
進(jìn)入函數(shù)調(diào)用時，也會創(chuàng)建一個新的Scope Chain，包括同一個函數(shù)的遞歸調(diào)用，退出函數(shù)時這個Scope Chain被丟棄。新建的Scope Chain第一個對象是Activation Object，接下來的內(nèi)容與內(nèi)部[[Scope]]上存儲的Scope Chain內(nèi)容完全一樣。
Eval Code
進(jìn)入Eval Code執(zhí)行時會創(chuàng)建一個新的Scope Chain，內(nèi)容與當(dāng)前執(zhí)行上下文的Scope Chain完全一樣。
實例說明
Scope Chain的原理就上面這些，必須結(jié)合JS代碼的執(zhí)行、Variable Instantiation的細(xì)節(jié)處理，才能理解上面這些如何產(chǎn)生作用，下面用一個簡單的場景來綜合說明。假設(shè)下面是一段JavaScript的Global Code:
var outerVar1="variable in global code";
function fn1(arg1, arg2){
var innerVar1="variable in function code";
function fn2() { return outerVar1+" - "+innerVar1+" - "+" - "+(arg1 + arg2); }
return fn2();
}
var outerVar2=fn1(10, 20);執(zhí)行處理過程大致如下:
1. 初始化Global Object即windo0,0)">20);執(zhí)行處理過程大致如下:
1. 初始化Global Object即window對象，Variable Object為window對象本身。創(chuàng)建Scope Chain對象，假設(shè)為scope_1，其中只包含window對象。
2. 掃描JS源代碼(讀入源代碼、可能有詞法語法分析過程)，從結(jié)果中可以得到定義的變量名、函數(shù)對象。按照掃描順序:
2.1 發(fā)現(xiàn)變量outerVar1，在window對象上添加outerVar1屬性，值為undefined；
2.2 發(fā)現(xiàn)函數(shù)fn1的定義，使用這個定義創(chuàng)建函數(shù)對象，傳給創(chuàng)建過程的Scope Chain為scope_1。將結(jié)果添加到window的屬性中，名字為fn1，值為返回的函數(shù)對象。注意fn1的內(nèi)部[[Scope]]就是 scope_1。另外注意，創(chuàng)建過程并不會對函數(shù)體中的JS代碼做特殊處理，可以理解為只是將函數(shù)體JS代碼的掃描結(jié)果保存在函數(shù)對象的內(nèi)部屬性上，在函 數(shù)執(zhí)行時再做進(jìn)一步處理。這對理解Function Code，尤其是嵌套函數(shù)定義中的Variable Instantiation很關(guān)鍵；
2.3 發(fā)現(xiàn)變量outerVar2，在window對象上添加outerVar2屬性，值為undefined；
3. 執(zhí)行outerVar1賦值語句，賦值為"variable in global code"。
4. 執(zhí)行函數(shù)fn1，得到返回值:
4.1 創(chuàng)建Activation Object，假設(shè)為activation_1；創(chuàng)建一個新的Scope Chain，假設(shè)為scope_2，scope_2中第一個對象為activation_1，第二個對象為window對象(取自fn1的 [[Scope]]，即scope_1中的內(nèi)容)；
4.2 處理參數(shù)列表。在activation_1上設(shè)置屬性arg1、arg2，值分別為10、20。創(chuàng)建arguments對象并進(jìn)行設(shè)置，將arguments設(shè)置為activation_1的屬性；
4.3 對fn1的函數(shù)體執(zhí)行類似步驟2的處理過程:
4.3.1 發(fā)現(xiàn)變量innerVar1，在activation_1對象上添加innerVar1屬性，值為undefine；
4.3.2 發(fā)現(xiàn)函數(shù)fn2的定義，使用這個定義創(chuàng)建函數(shù)對象，傳給創(chuàng)建過程的Scope Chain為scope_2(函數(shù)fn1的Scope Chain為當(dāng)前執(zhí)行上下文的內(nèi)容)。將結(jié)果添加到activation_1的屬性中，名字為fn2，值為返回的函數(shù)對象。注意fn2的內(nèi)部 [[Scope]]就是scope_2；
4.4 執(zhí)行innerVar1賦值語句，賦值為"variable in function code"。
4.5 執(zhí)行fn2:
4.5.1 創(chuàng)建Activation Object，假設(shè)為activation_2；創(chuàng)建一個新的Scope Chain，假設(shè)為scope_3，scope_3中第一個對象為activation_2，接下來的對象依次為activation_1、window 對象(取自fn2的[[Scope]]，即scope_2)；
4.5.2 處理參數(shù)列表。因為fn2沒有參數(shù)，所以只用創(chuàng)建arguments對象并設(shè)置為activation_2的屬性。
4.5.3 對fn2的函數(shù)體執(zhí)行類似步驟2的處理過程，沒有發(fā)現(xiàn)變量定義和函數(shù)聲明。
4.5.4 執(zhí)行函數(shù)體。對任何一個變量引用，從scope_3上進(jìn)行搜索，這個示例中，outerVar1將在window上找到；innerVar1、arg1、arg2將在activation_1上找到。
4.5.5 丟棄scope_3、activation_2(指它們可以被垃圾回收了)。
4.5.6 返回fn2的返回值。
4.6 丟棄activation_1、scope_2。
4.7 返回結(jié)果。
5. 將結(jié)果賦值給outerVar2。
其它情況下Scope Chain、Variable Instantiation處理類似上面的過程進(jìn)行分析就行了。
根據(jù)上面的實例說明，就可以解釋下面這個測試代碼的結(jié)果:
//Passed in FF2.0, IE7, Opera9.25, Safari3.0.4
function fn(obj){
return {
//test whether exists a local variable "outerVar" on obj
exists: Object.prototype.hasOwnProperty.call(obj, "outerVar"),
//test the value of the variable "outerVar"
value: obj.outerVar
};
}
var result1 = fn(window);
var outerVar = "WWW";
var result2 = fn(window);
document.write(result1.exists + " " + result1.value); //result: true undefined
document.write("<br />");
document.write(result2.exists + " " + result2.value); //result: true WWWresult1調(diào)用的地方，outerVar聲明和賦值的語句還沒有被執(zhí)行，但是測試結(jié)果window對象已經(jīng)擁有一個本地屬性outerVar，其值為 undefined。result2的地方outerVar已經(jīng)賦值，所以window.outerVar的值已經(jīng)有了。實際使用中不要出現(xiàn)這種先使用， 后定義的情況，否則某些情況下會有問題，因為會涉及到一些規(guī)范中沒有提及，不同廠商實現(xiàn)方式上不一致的地方。
一些特殊處理
1. with(obj) { ... }這個語法的實現(xiàn)方式，是在當(dāng)前的Scope Chain最前面位置插入obj這個對象，這樣就會先在obj上搜索是否有相應(yīng)名字的屬性存在。其它類似的還有catch語句。
2. 前面對arguments對象的詳細(xì)說明中，提到了對函數(shù)遞歸調(diào)用的支持問題，了解到了匿名函數(shù)使用arguments.callee來實現(xiàn)引用自己，而 命名函數(shù)可以在函數(shù)體內(nèi)引用自己，根據(jù)上面Scope Chain的工作原理我們還無法解釋這個現(xiàn)象，因為這里有個特殊處理。
任何時候創(chuàng)建一個命名函數(shù)對象時，JavaScript引擎會在當(dāng)前執(zhí)行上下文Scope Chain的最前面插入一個對象，這個對象使用new Object()方式創(chuàng)建，并將這個Scope Chain傳給Function的構(gòu)造函數(shù)[[Construct]]，最終創(chuàng)建出來的函數(shù)對象內(nèi)部[[Scope]]上將包含這個object對象。創(chuàng) 建過程返回之后，JavaScript引擎在object上添加一個屬性，名字為函數(shù)名，值為返回的函數(shù)對象，然后從當(dāng)前執(zhí)行上下文的Scope Chain中移除它。這樣函數(shù)對象的Scope Chain中第一個對象就是對自己的引用，而移除操作則確保了對函數(shù)對象創(chuàng)建處Scope Chain的恢復(fù)。
this關(guān)鍵字處理
執(zhí)行上下文包含的另一個概念是this關(guān)鍵字。
Global Code中this關(guān)鍵字為Global Object；函數(shù)調(diào)用時this關(guān)鍵字為調(diào)用者，例如obj1.fn1()，在fn1中this對象為obj1；Eval Code中this關(guān)鍵字為當(dāng)前執(zhí)行上下文的Variable Object。
在函數(shù)調(diào)用時，JavaScript提供一個讓用戶自己指定this關(guān)鍵字值的機會，即每個函數(shù)都有的call、apply方法。例如:
fn1.call(obj1, arg1, arg2, ...)或者fn1.apply(obj1, argArray)，都是將obj1作為this關(guān)鍵字，調(diào)用執(zhí)行fn1函數(shù)，后面的參數(shù)都作為函數(shù)fn1的參數(shù)。如果obj1為null或 undefined，則Global Object將作為this關(guān)鍵字的值；如果obj1不是Object類型，則轉(zhuǎn)化為Object類型。它們之間的唯一區(qū)別在于，apply允許以數(shù)組的 方式提供各個參數(shù)，而call方法必須一個一個參數(shù)的給。
前面的測試示例代碼中有多處運用到了這個方法。例如window對象并沒有hasOwnProperty方法，使用Object.prototype.hasOwnProperty.call(window, "propertyName")也可以測試它是否擁有某個本地屬性。
JavaScript中的閉包Closures
示例：
//Passed in FF2.0, IE7, Opera9.25, Safari3.0.4
function outer(){
var a="aaa";
var b="bbb";
return function(){ return a + " " + b; };
}
var inner=outer();
document.write(inner());outer返回的是一個內(nèi)嵌函數(shù)，內(nèi)嵌函數(shù)使用了outer的局部變量a和b。照理outer的局部變量在返回時就超出了作用域因此inner()調(diào)用無 法使用才對。這就是閉包Closure，即函數(shù)調(diào)用返回了一個內(nèi)嵌函數(shù)，而內(nèi)嵌函數(shù)引用了外部函數(shù)的局部變量、參數(shù)等這些應(yīng)當(dāng)被關(guān)閉(Close)了的資 源。
根據(jù)前面Scope Chain的理解可以解釋，返回的內(nèi)嵌函數(shù)已經(jīng)持有了構(gòu)造它時的Scope Chain，雖然outer返回導(dǎo)致這些對象超出了作用域、生存期范圍，但JavaScript使用自動垃圾回收來釋放對象內(nèi)存: 按照規(guī)則定期檢查，對象沒有任何引用才被釋放。因此上面的代碼能夠正確運行。w對象，Variable Object為window對象本身。創(chuàng)建Scope Chain對象，假設(shè)為scope_1，其中只包含window對象。
2. 掃描JS源代碼(讀入源代碼、可能有詞法語法分析過程)，從結(jié)果中可以得到定義的變量名、函數(shù)對象。按照掃描順序:
2.1 發(fā)現(xiàn)變量outerVar1，在window對象上添加outerVar1屬性，值為undefined；
2.2 發(fā)現(xiàn)函數(shù)fn1的定義，使用這個定義創(chuàng)建函數(shù)對象，傳給創(chuàng)建過程的Scope Chain為scope_1。將結(jié)果添加到window的屬性中，名字為fn1，值為返回的函數(shù)對象。注意fn1的內(nèi)部[[Scope]]就是 scope_1。另外注意，創(chuàng)建過程并不會對函數(shù)體中的JS代碼做特殊處理，可以理解為只是將函數(shù)體JS代碼的掃描結(jié)果保存在函數(shù)對象的內(nèi)部屬性上，在函 數(shù)執(zhí)行時再做進(jìn)一步處理。這對理解Function Code，尤其是嵌套函數(shù)定義中的Variable Instantiation很關(guān)鍵；
2.3 發(fā)現(xiàn)變量outerVar2，在window對象上添加outerVar2屬性，值為undefined；
3. 執(zhí)行outerVar1賦值語句，賦值為"variable in global code"。
4. 執(zhí)行函數(shù)fn1，得到返回值:
4.1 創(chuàng)建Activation Object，假設(shè)為activation_1；創(chuàng)建一個新的Scope Chain，假設(shè)為scope_2，scope_2中第一個對象為activation_1，第二個對象為window對象(取自fn1的 [[Scope]]，即scope_1中的內(nèi)容)；
4.2 處理參數(shù)列表。在activation_1上設(shè)置屬性arg1、arg2，值分別為10、20。創(chuàng)建arguments對象并進(jìn)行設(shè)置，將arguments設(shè)置為activation_1的屬性；
4.3 對fn1的函數(shù)體執(zhí)行類似步驟2的處理過程:
4.3.1 發(fā)現(xiàn)變量innerVar1，在activation_1對象上添加innerVar1屬性，值為undefine；
4.3.2 發(fā)現(xiàn)函數(shù)fn2的定義，使用這個定義創(chuàng)建函數(shù)對象，傳給創(chuàng)建過程的Scope Chain為scope_2(函數(shù)fn1的Scope Chain為當(dāng)前執(zhí)行上下文的內(nèi)容)。將結(jié)果添加到activation_1的屬性中，名字為fn2，值為返回的函數(shù)對象。注意fn2的內(nèi)部 [[Scope]]就是scope_2；
4.4 執(zhí)行innerVar1賦值語句，賦值為"variable in function code"。
4.5 執(zhí)行fn2:
4.5.1 創(chuàng)建Activation Object，假設(shè)為activation_2；創(chuàng)建一個新的Scope Chain，假設(shè)為scope_3，scope_3中第一個對象為activation_2，接下來的對象依次為activation_1、window 對象(取自fn2的[[Scope]]，即scope_2)；
4.5.2 處理參數(shù)列表。因為fn2沒有參數(shù)，所以只用創(chuàng)建arguments對象并設(shè)置為activation_2的屬性。
4.5.3 對fn2的函數(shù)體執(zhí)行類似步驟2的處理過程，沒有發(fā)現(xiàn)變量定義和函數(shù)聲明。
4.5.4 執(zhí)行函數(shù)體。對任何一個變量引用，從scope_3上進(jìn)行搜索，這個示例中，outerVar1將在window上找到；innerVar1、arg1、arg2將在activation_1上找到。
4.5.5 丟棄scope_3、activation_2(指它們可以被垃圾回收了)。
4.5.6 返回fn2的返回值。
4.6 丟棄activation_1、scope_2。
4.7 返回結(jié)果。
5. 將結(jié)果賦值給outerVar2。
其它情況下Scope Chain、Variable Instantiation處理類似上面的過程進(jìn)行分析就行了。
根據(jù)上面的實例說明，就可以解釋下面這個測試代碼的結(jié)果:
//Passed in FF2.0, IE7, Opera9.25, Safari3.0.4
function fn(obj){
return {
//test whether exists a local variable "outerVar" on obj
exists: Object.prototype.hasOwnProperty.call(obj, "outerVar"),
//test the value of the variable "outerVar"
value: obj.outerVar
};
}
var result1 = fn(window);
var outerVar = "WWW";
var result2 = fn(window);
document.write(result1.exists + " " + result1.value); //result: true undefined
document.write("<br />");
document.write(result2.exists + " " + result2.value); //result: true WWWresult1調(diào)用的地方，outerVar聲明和賦值的語句還沒有被執(zhí)行，但是測試結(jié)果window對象已經(jīng)擁有一個本地屬性outerVar，其值為 undefined。result2的地方outerVar已經(jīng)賦值，所以window.outerVar的值已經(jīng)有了。實際使用中不要出現(xiàn)這種先使用， 后定義的情況，否則某些情況下會有問題，因為會涉及到一些規(guī)范中沒有提及，不同廠商實現(xiàn)方式上不一致的地方。
一些特殊處理
1. with(obj) { ... }這個語法的實現(xiàn)方式，是在當(dāng)前的Scope Chain最前面位置插入obj這個對象，這樣就會先在obj上搜索是否有相應(yīng)名字的屬性存在。其它類似的還有catch語句。
2. 前面對arguments對象的詳細(xì)說明中，提到了對函數(shù)遞歸調(diào)用的支持問題，了解到了匿名函數(shù)使用arguments.callee來實現(xiàn)引用自己，而 命名函數(shù)可以在函數(shù)體內(nèi)引用自己，根據(jù)上面Scope Chain的工作原理我們還無法解釋這個現(xiàn)象，因為這里有個特殊處理。
任何時候創(chuàng)建一個命名函數(shù)對象時，JavaScript引擎會在當(dāng)前執(zhí)行上下文Scope Chain的最前面插入一個對象，這個對象使用new Object()方式創(chuàng)建，并將這個Scope Chain傳給Function的構(gòu)造函數(shù)[[Construct]]，最終創(chuàng)建出來的函數(shù)對象內(nèi)部[[Scope]]上將包含這個object對象。創(chuàng) 建過程返回之后，JavaScript引擎在object上添加一個屬性，名字為函數(shù)名，值為返回的函數(shù)對象，然后從當(dāng)前執(zhí)行上下文的Scope Chain中移除它。這樣函數(shù)對象的Scope Chain中第一個對象就是對自己的引用，而移除操作則確保了對函數(shù)對象創(chuàng)建處Scope Chain的恢復(fù)。
this關(guān)鍵字處理
執(zhí)行上下文包含的另一個概念是this關(guān)鍵字。
Global Code中this關(guān)鍵字為Global Object；函數(shù)調(diào)用時this關(guān)鍵字為調(diào)用者，例如obj1.fn1()，在fn1中this對象為obj1；Eval Code中this關(guān)鍵字為當(dāng)前執(zhí)行上下文的Variable Object。
在函數(shù)調(diào)用時，JavaScript提供一個讓用戶自己指定this關(guān)鍵字值的機會，即每個函數(shù)都有的call、apply方法。例如:
fn1.call(obj1, arg1, arg2, ...)或者fn1.apply(obj1, argArray)，都是將obj1作為this關(guān)鍵字，調(diào)用執(zhí)行fn1函數(shù)，后面的參數(shù)都作為函數(shù)fn1的參數(shù)。如果obj1為null或 undefined，則Global Object將作為this關(guān)鍵字的值；如果obj1不是Object類型，則轉(zhuǎn)化為Object類型。它們之間的唯一區(qū)別在于，apply允許以數(shù)組的 方式提供各個參數(shù)，而call方法必須一個一個參數(shù)的給。
前面的測試示例代碼中有多處運用到了這個方法。例如window對象并沒有hasOwnProperty方法，使用Object.prototype.hasOwnProperty.call(window, "propertyName")也可以測試它是否擁有某個本地屬性。
JavaScript中的閉包Closures
示例：
//Passed in FF2.0, IE7, Opera9.25, Safari3.0.4
function outer(){
var a="aaa";
var b="bbb";
return function(){ return a + " " + b; };
}
var inner=outer();
document.write(inner());outer返回的是一個內(nèi)嵌函數(shù)，內(nèi)嵌函數(shù)使用了outer的局部變量a和b。照理outer的局部變量在返回時就超出了作用域因此inner()調(diào)用無 法使用才對。這就是閉包Closure，即函數(shù)調(diào)用返回了一個內(nèi)嵌函數(shù)，而內(nèi)嵌函數(shù)引用了外部函數(shù)的局部變量、參數(shù)等這些應(yīng)當(dāng)被關(guān)閉(Close)了的資 源。
根據(jù)前面Scope Chain的理解可以解釋，返回的內(nèi)嵌函數(shù)已經(jīng)持有了構(gòu)造它時的Scope Chain，雖然outer返回導(dǎo)致這些對象超出了作用域、生存期范圍，但JavaScript使用自動垃圾回收來釋放對象內(nèi)存: 按照規(guī)則定期檢查，對象沒有任何引用才被釋放。因此上面的代碼能夠正確運行。
JavaScript技術(shù)：JavaScript對象模型-執(zhí)行模型，轉(zhuǎn)載需保留來源！
鄭重聲明：本文版權(quán)歸原作者所有，轉(zhuǎn)載文章僅為傳播更多信息之目的，如作者信息標(biāo)記有誤，請第一時間聯(lián)系我們修改或刪除，多謝。
