數(shù)據(jù)類型
基本數(shù)據(jù)類型
基本數(shù)據(jù)類型是JS語言最底層的實(shí)現(xiàn)。
簡(jiǎn)單數(shù)值類型: 有Undefined, Null, Boolean, Number和String。注意，描述中的英文單詞在這里僅指數(shù)據(jù)類型的名稱，并不特指JS的全局對(duì)象N an, Boolean, Number, String等，它們?cè)诟拍钌系膮^(qū)別是比較大的。
對(duì)象: 一個(gè)無序?qū)傩缘募?，這些屬性的值為簡(jiǎn)單數(shù)值類型、對(duì)象或者函數(shù)。同上，這里的對(duì)象并不特指全局對(duì)象Object。
函數(shù): 函數(shù)是對(duì)象的一種，實(shí)現(xiàn)上內(nèi)部屬性[[Class]]值為"Function"，表明它是函數(shù)類型，除了對(duì)象的內(nèi)部屬性方法外，還有 [[Construct]]、[[Call]]、[[Scope]]等內(nèi)部屬性。函數(shù)作為函數(shù)調(diào)用與構(gòu)造器(使用new關(guān)鍵字創(chuàng)建實(shí)例對(duì)象)的處理機(jī)制不一樣(Function對(duì)象除外)，內(nèi)部方法[[Construct]]用于實(shí)現(xiàn)作為構(gòu)造器的邏輯，方法[[Call]]實(shí)現(xiàn)作為函數(shù)調(diào)用的邏輯。同上，這里的函數(shù)并不特指全局對(duì)象Function。
函數(shù)在JS這個(gè)Prototype語言中可以看作是面向?qū)ο笳Z言的類，可以用它來構(gòu)造對(duì)象實(shí)例。既然函數(shù)可以看作是類，所以每一個(gè)函數(shù)可以看作是一種擴(kuò)展數(shù)據(jù)類型。
內(nèi)置數(shù)據(jù)類型(內(nèi)置對(duì)象)
Function: 函數(shù)類型的用戶接口。
Object: 對(duì)象類型的用戶接口。
Boolean, Number, String: 分別為這三種簡(jiǎn)單數(shù)值類型的對(duì)象包裝器，對(duì)象包裝在概念上有點(diǎn)類似C#中的Box/Unbox。
Date, Array, RegExp: 可以把它們看作是幾種內(nèi)置的擴(kuò)展數(shù)據(jù)類型。
首先，F(xiàn)unction, Object, Boolean, Number, String, Date, Array, RegExp等都是JavaScript語言的內(nèi)置對(duì)象，它們都可以看作是函數(shù)的派生類型，例如Number instanceof Function為true，Number instanceof Object為true。在這個(gè)意義上，可以將它們跟用戶定義的函數(shù)等同看待。
其次，它們各自可以代表一種數(shù)據(jù)類型，由JS引擎用native code或內(nèi)置的JS代碼實(shí)現(xiàn)，是暴露給開發(fā)者對(duì)這些內(nèi)置數(shù)據(jù)類型進(jìn)行操作的接口。在這個(gè)意義上，它們都是一種抽象的概念，后面隱藏了具體的實(shí)現(xiàn)機(jī)制。
在每一個(gè)提到Number, Function等單詞的地方，應(yīng)該迅速的在思維中將它們實(shí)例化為上面的兩種情況之一。
數(shù)據(jù)類型實(shí)現(xiàn)模型描述

Build-in *** data structure: 指JS內(nèi)部用于實(shí)現(xiàn)***類型的數(shù)據(jù)結(jié)構(gòu)，這些結(jié)構(gòu)我們基本上無法直接操作。
Build-in *** object: 指JS內(nèi)置的Number, String, Boolean等這些對(duì)象，這是JS將內(nèi)部實(shí)現(xiàn)的數(shù)據(jù)類型暴露給開發(fā)者使用的接口。
Build-in *** constructor: 指JS內(nèi)置的一些構(gòu)造器，用來構(gòu)造相應(yīng)類型的對(duì)象實(shí)例。它們被包裝成函數(shù)對(duì)象暴露出來，例如我們可以使用下面的方法訪問到這些函數(shù)對(duì)象:

//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

具體實(shí)現(xiàn)上，上圖中橫向之間可能也存在關(guān)聯(lián)，例如對(duì)于build-in data structure和constructor，F(xiàn)unction、 Date、 Array、 RegExp等都可以繼承Object的結(jié)構(gòu)而實(shí)現(xiàn)，但這是具體實(shí)現(xiàn)相關(guān)的事情了。
關(guān)于簡(jiǎn)單數(shù)值類型的對(duì)象化
這是一個(gè)細(xì)微的地方，下面描述對(duì)于Boolean, String和Number這三種簡(jiǎn)單數(shù)值類型都適用，以Number為例說明。
JS 規(guī)范要求: 使用var num1=123;這樣的代碼，直接返回基本數(shù)據(jù)類型，就是說返回的對(duì)象不是派生自Number和Object類型，用num1 instanceof Object測(cè)試為false；使用new關(guān)鍵字創(chuàng)建則返回Number類型，例如var num2=new Number(123); num2 instanceof Number為true。
將Number當(dāng)作函數(shù)調(diào)用，返回結(jié)果會(huì)轉(zhuǎn)換成簡(jiǎn)單數(shù)值類型。下面是測(cè)試代碼:

//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

雖然我們得到了一個(gè)簡(jiǎn)單數(shù)值類型，但它看起來仍然是一個(gè)JS Object對(duì)象，具有Object以及相應(yīng)類型的所有屬性和方法，使用上基本沒有差別，唯一不同之處是instanceof的測(cè)試結(jié)果。
Prototype繼承
Prototype
每個(gè)對(duì)象都有一個(gè)[[Prototype]]的內(nèi)部屬性，它的值為null或者另外一個(gè)對(duì)象。函數(shù)對(duì)象都有一個(gè)顯示的prototype屬性，它并不是內(nèi)部 [[Prototype]]屬性。不同的JS引擎實(shí)現(xiàn)者可以將內(nèi)部[[Prototype]]屬性命名為任何名字，并且設(shè)置它的可見性，只在JS引擎內(nèi)部使用。雖然無法在JS代碼中訪問到內(nèi)部[[Prototype]](FireFox中可以，名字為__proto__因?yàn)镸ozilla將它公開了)，但可以使用對(duì)象的isPrototypeOf()方法進(jìn)行測(cè)試，注意這個(gè)方法會(huì)在整個(gè)Prototype鏈上進(jìn)行判斷。
使用obj.propName訪問一個(gè)對(duì)象的屬性時(shí)，按照下面的步驟進(jìn)行處理(假設(shè)obj的內(nèi)部[[Prototype]]屬性名為__proto__):
1. 如果obj存在propName屬性，返回屬性的值，否則
2. 如果obj.__proto__為null，返回undefined，否則
3. 返回obj.__proto__.propName
調(diào)用對(duì)象的方法跟訪問屬性搜索過程一樣，因?yàn)榉椒ǖ暮瘮?shù)對(duì)象就是對(duì)象的一個(gè)屬性值。
提示: 上面步驟中隱含了一個(gè)遞歸過程，步驟3中obj.__proto__是另外一個(gè)對(duì)象，同樣將采用1, 2, 3這樣的步驟來搜索propName屬性。
例如下圖所示，object1將具備屬性prop1, prop2, prop3以及方法fn1, fn2, fn3。圖中虛線箭頭表示prototype鏈。

這就是基于Prototype的繼承和共享。其中object1的方法fn2來自object2，概念上即object2重寫了object3的方法fn2。
JavaScript對(duì)象應(yīng)當(dāng)都通過prototype鏈關(guān)聯(lián)起來，最頂層是Object，即對(duì)象都派生自O(shè)bject類型。
類似C++等面向?qū)ο笳Z言用類(被抽象了的類型)來承載方法，用對(duì)象(實(shí)例化對(duì)象)承載屬性，Prototype語言只用實(shí)例化的對(duì)象來承載方法和屬性。本質(zhì)區(qū)別是前者基于內(nèi)存結(jié)構(gòu)的描述來實(shí)現(xiàn)繼承，后者基于具體的內(nèi)存塊實(shí)現(xiàn)。
對(duì)象創(chuàng)建過程
JS 中只有函數(shù)對(duì)象具備類的概念，因此要?jiǎng)?chuàng)建一個(gè)對(duì)象，必須使用函數(shù)對(duì)象。函數(shù)對(duì)象內(nèi)部有[[Construct]]方法和[[Call]]方法， [[Construct]]用于構(gòu)造對(duì)象，[[Call]]用于函數(shù)調(diào)用，只有使用new操作符時(shí)才觸發(fā)[[Construct]]邏輯。
var obj=new Object(); 是使用內(nèi)置的Object這個(gè)函數(shù)對(duì)象創(chuàng)建實(shí)例化對(duì)象obj。var obj={};和var obj=[];這種代碼將由JS引擎觸發(fā)Object和Array的構(gòu)造過程。function fn(){}; var myObj=new fn();是使用用戶定義的類型創(chuàng)建實(shí)例化對(duì)象。
new Fn(args)的創(chuàng)建過程如下(即函數(shù)對(duì)象的[[Construct]]方法處理邏輯，對(duì)象的創(chuàng)建過程)。另外函數(shù)對(duì)象本身的創(chuàng)建過程(指定義函數(shù)或者用Function創(chuàng)建一個(gè)函數(shù)對(duì)象等方式)雖然也使用了下面的處理邏輯，但有特殊的地方，后面再描述。
1. 創(chuàng)建一個(gè)build-in object對(duì)象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類型，則返回這個(gè)值，否則返回obj
注意步驟2中， prototype指對(duì)象顯示的prototype屬性，而[[Prototype]]則代表對(duì)象內(nèi)部Prototype屬性(隱式的)。
構(gòu)成對(duì)象Prototype鏈的是內(nèi)部隱式的[[Prototype]]，而并非對(duì)象顯示的prototype屬性。顯示的prototype只有在函數(shù)對(duì)象上才有意義，從上面的創(chuàng)建過程可以看到，函數(shù)的prototype被賦給派生對(duì)象隱式[[Prototype]]屬性，這樣根據(jù)Prototype規(guī)則，派生對(duì)象和函數(shù)的prototype對(duì)象之間才存在屬性、方法的繼承/共享關(guān)系。
用代碼來做一些驗(yà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 + "
"); //result: aaa
document.write(obj.attr2 + "
"); //result: bbb
document.write(obj instanceof fn); //result: true
document.write("
");
//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 + "
"); //result: aaa
document.write(obj.attr2 + "
"); //result: bbb
document.write(obj instanceof fn); //result: false

關(guān)于創(chuàng)建過程返回值的驗(yàn)證:

//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 + "
"); //result: 111
document.write(obj.attr2 + "
"); //result: 222
document.write(obj instanceof fn); //result: false

做個(gè)練習(xí)
經(jīng)過上面的理解應(yīng)，請(qǐng)寫出下面這幅圖的實(shí)現(xiàn)代碼。圖中CF是一個(gè)函數(shù)，Cfp是CF的prototype對(duì)象，cf1, cf2, cf3, cf4, cf5都是CF的實(shí)例對(duì)象。虛線箭頭表示隱式Prototype關(guān)系，實(shí)線箭頭表示顯示prototype關(guān)系。

供參考的實(shí)現(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 + "
"); //result: CFP1 in Cfp
document.write(cf1.q1 + "
"); //result: aaa
document.write(cf1.q2 + "
"); //result: bbb

本地屬性與繼承屬性
對(duì)象通過隱式Prototype鏈能夠?qū)崿F(xiàn)屬性和方法的繼承，但prototype也是一個(gè)普通對(duì)象，就是說它是一個(gè)普通的實(shí)例化的對(duì)象，而不是純粹抽象的數(shù)據(jù)結(jié)構(gòu)描述。所以就有了這個(gè)本地屬性與繼承屬性的問題。
首先看一下設(shè)置對(duì)象屬性時(shí)的處理過程。JS定義了一組attribute，用來描述對(duì)象的屬性property，以表明屬性property是否可以在JavaScript代碼中設(shè)值、被for in枚舉等。
obj.propName=value的賦值語句處理步驟如下:
1. 如果propName的attribute設(shè)置為不能設(shè)值，則返回
2. 如果obj.propName不存在，則為obj創(chuàng)建一個(gè)屬性，名稱為propName
3. 將obj.propName的值設(shè)為value
可以看到，設(shè)值過程并不會(huì)考慮Prototype鏈，道理很明顯，obj的內(nèi)部[[Prototype]]是一個(gè)實(shí)例化的對(duì)象，它不僅僅向obj共享屬性，還可能向其它對(duì)象共享屬性，修改它可能影響其它對(duì)象。
用上面CF, Cfp的示例來說明，實(shí)例對(duì)象cf1具有本地屬性q1, q2以及繼承屬性CFP1，如果執(zhí)行cf1.CFP1=""，那么cf1就具有本地屬性CFP1了，測(cè)試結(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 + "
"); //result: CFP1 in Cfp
document.write(cf2.CFP1 + "
"); //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 + "
"); //result: new value for cf1
document.write(cf2.CFP1 + "
"); //result: new value for Cfp

語義上的混亂?
還是使用上面CF, Cfp示例的場(chǎng)景。
根據(jù)Prototype的機(jī)制，我們可以說對(duì)象cf1, cf2等都繼承了對(duì)象Cfp的屬性和方法，所以應(yīng)該說他們之間存在繼承關(guān)系。屬性的繼承/共享是沿著隱式Prototype鏈作用的，所以繼承關(guān)系也應(yīng)當(dāng)理解為沿著這個(gè)鏈。
我們?cè)倏磇nstanceOf操作，只有cf1 instanceOf CF才成立，我們說cf1是CF的實(shí)例對(duì)象，CF充當(dāng)了類的角色，而不會(huì)說cf1是Cfp的實(shí)例對(duì)象，這樣我們應(yīng)當(dāng)說cf1繼承自CF? 但CF充當(dāng)?shù)闹皇且粋€(gè)第三方工廠的角色，它跟cf1之間并沒有屬性繼承這個(gè)關(guān)系。
把CF, Cfp看作一個(gè)整體來理解也同樣牽強(qiáng)。
Prototype就是Prototype，沒有必要強(qiáng)把JavaScript與面向?qū)ο蟾拍罱Y(jié)合起來， JavaScript只具備有限的面向?qū)ο竽芰?，從另外的角度我們可以把它看成函?shù)語言、動(dòng)態(tài)語言，所以它是吸收了多種語言特性的精簡(jiǎn)版。
對(duì)象模型
Where are we?
1. 了解了JavaScript的數(shù)據(jù)類型，清楚了象Number這樣的系統(tǒng)內(nèi)置對(duì)象具有多重身份: a)它們本身是一個(gè)函數(shù)對(duì)象，只是由引擎內(nèi)部實(shí)現(xiàn)而已，b)它們代表一種數(shù)據(jù)類型，我們可以用它們定義、操作相應(yīng)類型的數(shù)據(jù)，c)在它們背后隱藏了引擎的內(nèi)部實(shí)現(xiàn)機(jī)制，例如內(nèi)部的數(shù)據(jù)結(jié)構(gòu)、各種被包裝成了JavaScript對(duì)象的構(gòu)造器等。
2. 了解了Prototype機(jī)制，知道對(duì)象是如何通過它們繼承屬性和方法，知道了在創(chuàng)建對(duì)象過程中JS引擎內(nèi)部是如何設(shè)置Prototype關(guān)系的。
接下來對(duì)用戶自定義函數(shù)對(duì)象本身的創(chuàng)建過程進(jìn)行了解之后，我們就可以對(duì)JavaScript的對(duì)象模型來一個(gè)整體性的overview了。
函數(shù)對(duì)象創(chuàng)建過程
JavaScript代碼中定義函數(shù)，或者調(diào)用Function創(chuàng)建函數(shù)時(shí)，最終都會(huì)以類似這樣的形式調(diào)用Function函數(shù):var newFun=Function(funArgs, funBody); 。創(chuàng)建函數(shù)對(duì)象的主要步驟如下:
1. 創(chuàng)建一個(gè)build-in object對(duì)象fn
2. 將fn的內(nèi)部[[Prototype]]設(shè)為Function.prototype
3. 設(shè)置內(nèi)部的[[Call]]屬性，它是內(nèi)部實(shí)現(xiàn)的一個(gè)方法，處理邏輯參考對(duì)象創(chuàng)建過程的步驟3
4. 設(shè)置內(nèi)部的[[Construct]]屬性，它是內(nèi)部實(shí)現(xiàn)的一個(gè)方法，處理邏輯參考對(duì)象創(chuàng)建過程的步驟1,2,3,4
5. 設(shè)置fn.length為funArgs.length，如果函數(shù)沒有參數(shù)，則將fn.length設(shè)置為0
6. 使用new Object()同樣的邏輯創(chuàng)建一個(gè)Object對(duì)象fnProto
7. 將fnProto.constructor設(shè)為fn
8. 將fn.prototype設(shè)為fnProto
9. 返回fn
步驟1跟步驟6的區(qū)別為，步驟1只是創(chuàng)建內(nèi)部用來實(shí)現(xiàn)Object對(duì)象的數(shù)據(jù)結(jié)構(gòu)(build-in object structure)，并完成內(nèi)部必要的初始化工作，但它的[[Prototype]]、[[Call]]、[[Construct]]等屬性應(yīng)當(dāng)為 null或者內(nèi)部初始化值，即我們可以理解為不指向任何對(duì)象(對(duì)[[Prototype]]這樣的屬性而言)，或者不包含任何處理(對(duì) [[Call]]、[[Construct]]這樣的方法而言)。步驟6則將按照前面描述的對(duì)象創(chuàng)建過程創(chuàng)建一個(gè)新的對(duì)象，它的 [[Prototype]]等被設(shè)置了。
從上面的處理步驟可以了解，任何時(shí)候我們定義一個(gè)函數(shù)，它的prototype是一個(gè)Object實(shí)例，這樣默認(rèn)情況下我們創(chuàng)建自定義函數(shù)的實(shí)例對(duì)象時(shí)，它們的Prototype鏈將指向Object.prototype。
另外，F(xiàn)unction一個(gè)特殊的地方，是它的[[Call]]和[[Construct]]處理邏輯一樣。
JavaScript對(duì)象模型

紅色虛線表示隱式Prototype鏈。
這張對(duì)象模型圖中包含了太多東西，不少地方需要仔細(xì)體會(huì)，可以寫些測(cè)試代碼進(jìn)行驗(yàn)證。徹底理解了這張圖，對(duì)JavaScript語言的了解也就差不多了。下面是一些補(bǔ)充說明:
1. 圖中有好幾個(gè)地方提到build-in Function constructor，這是同一個(gè)對(duì)象，可以測(cè)試驗(yàn)證:

//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

這說明了幾個(gè)問題: 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)建的對(duì)象: function fn1(){}; var obj1=new fn1();
    這些對(duì)象沒有本地constructor方法，但它們將從Prototype鏈上得到一個(gè)繼承的constructor方法，即fn.prototype.constructor，從函數(shù)對(duì)象的構(gòu)造過程可以知道，它就是fn本身了。
    右下角的obj1, obj2...objn范指用類似這樣的代碼創(chuàng)建的對(duì)象: var obj1=new Object();或var obj1={};或var obj1=new Number(123);或obj1=/\w+/;等等。所以這些對(duì)象Prototype鏈的指向、從Prototype鏈繼承而來的 constructor的值(指它們的constructor是build-in Number constructor還是build-in Object constructor等)等依賴于具體的對(duì)象類型。另外注意的是，var obj=new Object(123);這樣創(chuàng)建的對(duì)象，它的類型仍然是Number，即同樣需要根據(jù)參數(shù)值的類型來確定。
    同樣它們也沒有本地constructor，而是從Prototype鏈上獲得繼承的constructor方法，即build-in *** constructor，具體是哪一個(gè)由數(shù)據(jù)類型確定。
3. 關(guān)于圖中Prototype鏈的補(bǔ)充說明:
Object.prototype是整個(gè)鏈的終結(jié)點(diǎn)，它的內(nèi)部[[Prototype]]為null。
所有函數(shù)的Prototype鏈都指向Function.prototype。
Function 的Prototype鏈指向Function.prototype，這是規(guī)范要求的，因?yàn)樵O(shè)計(jì)者將Function設(shè)計(jì)為具有自舉性。Function的 Prototype鏈這樣設(shè)計(jì)之后，F(xiàn)unction.constructor==Function, Function instanceOf Function都為true。另外Function已經(jīng)是最頂層的構(gòu)造器，但Function本身也是一個(gè)函數(shù)對(duì)象，它必然是由某個(gè)東西創(chuàng)建出來的，這樣自舉在語義上合情合理。
Function.prototype的Prototype鏈指向Object.prototype，這也是規(guī)范強(qiáng)制要求的。首先Function.prototype是Function的一個(gè)實(shí)例對(duì)象(typeof Function.prototype可以知道它是一個(gè)Function，instanceOf無法通過測(cè)試，因?yàn)镻rototype鏈在內(nèi)部被額外設(shè)置了），所以按照Prototype的規(guī)則，F(xiàn)unction.prototype的內(nèi)部[[Prototype]]值應(yīng)當(dāng)為 Function.prototype這個(gè)對(duì)象，即它的Prototype鏈指向自己本身。這樣一方面在Prototype鏈上造成一個(gè)死循環(huán)，另一方面它本身成為了一個(gè)終結(jié)點(diǎn)，結(jié)果就是所有函數(shù)對(duì)象將不是派生自O(shè)bject了。加上這個(gè)強(qiáng)制要求之后，Prototype鏈只有唯一的一個(gè)終結(jié)點(diǎn)。
4. 因?yàn)镕unction.prototype是一個(gè)函數(shù)對(duì)象，所以它應(yīng)當(dāng)具有顯示的prototype屬性，即 Function.prototype.prototype，但只有FireFox中可以訪問到，IE、Opera、Safari都無法訪問。所以圖中用了個(gè)表示不存在的符號(hào)。
5. 用戶自定義函數(shù)(user defined functions)默認(rèn)情況下[[Prototype]]值是Object.prototype，即它的隱式Prototype鏈指向 Object.prototype，所以圖中就這樣表示了，但并不代表總是這樣，當(dāng)用戶設(shè)置了自定義函數(shù)的prototype屬性之后，情況就不同了。
執(zhí)行模型
執(zhí)行上下文(Execution Context)簡(jiǎn)介
JavaScript 代碼運(yùn)行的地方都存在執(zhí)行上下文，它是一個(gè)概念，一種機(jī)制，用來完成JavaScript運(yùn)行時(shí)作用域、生存期等方面的處理。執(zhí)行上下文包括 Variable Object、Variable Instatiation、Scope/Scope Chain等概念，在不同的場(chǎng)景/執(zhí)行環(huán)境下，處理上存在一些差異，下面先對(duì)這些場(chǎng)景進(jìn)行說明。
函數(shù)對(duì)象分為用戶自定義函數(shù)對(duì)象和系統(tǒng)內(nèi)置函數(shù)對(duì)象，對(duì)于用戶自定義函數(shù)對(duì)象將按照下面描述的機(jī)制進(jìn)行處理，但內(nèi)置函數(shù)對(duì)象與具體實(shí)現(xiàn)相關(guān)，ECMA規(guī)范對(duì)它們執(zhí)行上下文的處理沒有要求，即它們基本不適合本節(jié)描述的內(nèi)容。
執(zhí)行的JavaScript代碼分三種類型，后面會(huì)對(duì)這三種類型處理上不同的地方進(jìn)行說明:
1. Global Code，即全局的、不在任何函數(shù)里面的代碼，例如一個(gè)js文件、嵌入在HTML頁面中的js代碼等。
2. Eval Code，即使用eval()函數(shù)動(dòng)態(tài)執(zhí)行的JS代碼。
3. Function Code，即用戶自定義函數(shù)中的函數(shù)體JS代碼。
基本原理
在用戶自定義函數(shù)中，可以傳入?yún)?shù)、在函數(shù)中定義局部變量，函數(shù)體代碼可以使用這些入?yún)?、局部變量。背后的機(jī)制是什么樣呢？
當(dāng) JS執(zhí)行流進(jìn)入函數(shù)時(shí)，JavaScript引擎在內(nèi)部創(chuàng)建一個(gè)對(duì)象，叫做Variable Object。對(duì)應(yīng)函數(shù)的每一個(gè)參數(shù)，在Variable Object上添加一個(gè)屬性，屬性的名字、值與參數(shù)的名字、值相同。函數(shù)中每聲明一個(gè)變量，也會(huì)在Variable Object上添加一個(gè)屬性，名字就是變量名，因此為變量賦值就是給Variable Object對(duì)應(yīng)的屬性賦值。在函數(shù)中訪問參數(shù)或者局部變量時(shí)，就是在variable Object上搜索相應(yīng)的屬性，返回其值。
一般情況下Variable Object是一個(gè)內(nèi)部對(duì)象，JS代碼中無法直接訪問。規(guī)范中對(duì)其實(shí)現(xiàn)方式也不做要求，因此它可能只是引擎內(nèi)部的一種數(shù)據(jù)結(jié)構(gòu)。
大致處理方式就這樣，但作用域的概念不只這么簡(jiǎn)單，例如函數(shù)體中可以使用全局變量、函數(shù)嵌套定義時(shí)情況更復(fù)雜點(diǎn)。這些情況下怎樣處理？JavaScript 引擎將不同執(zhí)行位置上的Variable Object按照規(guī)則構(gòu)建一個(gè)鏈表，在訪問一個(gè)變量時(shí)，先在鏈表的第一個(gè)Variable Object上查找，如果沒有找到則繼續(xù)在第二個(gè)Variable Object上查找，直到搜索結(jié)束。這就是Scope/Scope Chain的大致概念。
下面是各個(gè)方面詳細(xì)的處理。
Global Object
JavaScript 的運(yùn)行環(huán)境都必須存在一個(gè)唯一的全局對(duì)象-Global Object，例如HTML中的window對(duì)象。Global Object是一個(gè)宿主對(duì)象，除了作為JavaScript運(yùn)行時(shí)的全局容器應(yīng)具備的職責(zé)外，ECMA規(guī)范對(duì)它沒有額外要求。它包Math、 String、Date、parseInt等JavaScript中內(nèi)置的全局對(duì)象、函數(shù)(都作為Global Object的屬性)，還可以包含其它宿主環(huán)境需要的一些屬性。
Variable Object
上面簡(jiǎn)述了Variable Object的基本概念。創(chuàng)建Variable Object，將參數(shù)、局部變量設(shè)置為Variable Object屬性的處理過程叫做Variable Instatiation-變量實(shí)例化，后面結(jié)合Scope Chain再進(jìn)行詳細(xì)說明。
Global Code
Variable Object就是Global Object，這是Variable Object唯一特殊的地方(指它是內(nèi)部的無法訪問的對(duì)象而言)。

var globalVariable = "WWW";
document.write(window.globalVariable); //result: WWW

上面代碼在Global Code方式下運(yùn)行，根據(jù)對(duì)Variable Object的處理，定義變量globalVariable時(shí)就會(huì)在Global Object(即window)對(duì)象上添加這個(gè)屬性，所以輸出是WWW這個(gè)值。
Function Code
Variable Object也叫做Activation Object(因?yàn)橛幸恍┎町惔嬖?，所以?guī)范中重新取一個(gè)名字以示區(qū)別，Global Code/Eval Code中叫Variable Object，F(xiàn)unction Code中就叫做Activation Object)。
每次進(jìn)入函數(shù)執(zhí)行都會(huì)創(chuàng)建一個(gè)新的Activation Object對(duì)象，然后創(chuàng)建一個(gè)arguments對(duì)象并設(shè)置為Activation Object的屬性，再進(jìn)行Variable Instantiation處理。
在退出函數(shù)時(shí)，Activation Object會(huì)被丟棄(并不是內(nèi)存釋放，只是可以被垃圾回收了)。
附arguments對(duì)象的屬性:
length: 為實(shí)際傳入?yún)?shù)的個(gè)數(shù)。注意，參考函數(shù)對(duì)象創(chuàng)建過程，函數(shù)對(duì)象上的length為函數(shù)定義時(shí)要求的參數(shù)個(gè)數(shù)；
callee: 為執(zhí)行的函數(shù)對(duì)象本身。目的是使函數(shù)對(duì)象能夠引用自己，例如需要遞歸調(diào)用的地方。
function fnName(...) { ... }這樣定義函數(shù)，它的遞歸調(diào)用可以在函數(shù)體內(nèi)使用fnName完成。var fn=function(...) { ... }這樣定義匿名函數(shù)，在函數(shù)體內(nèi)無法使用名字引用自己，通過arguments.callee就可以引用自己而實(shí)現(xiàn)遞歸調(diào)用。
參數(shù)列表: 調(diào)用者實(shí)際傳入的參數(shù)列表。這個(gè)參數(shù)列表提供一個(gè)使用索引訪問實(shí)際參數(shù)的方法。Variable Instantiation處理時(shí)會(huì)在Activation Object對(duì)象上添加屬性，前提是函數(shù)聲明時(shí)有指定參數(shù)列表。如果函數(shù)聲明中不給出參數(shù)列表，或者實(shí)際調(diào)用參數(shù)個(gè)數(shù)與聲明時(shí)的不一樣，可以通過 arguments訪問各個(gè)參數(shù)。
arguments中的參數(shù)列表與Activation Object上的參數(shù)屬性引用的是相同的參數(shù)對(duì)象(如果修改，在兩處都會(huì)反映出來)。規(guī)范并不要求arguments是一個(gè)數(shù)組對(duì)象，下面是一個(gè)測(cè)試:

//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] + "
"); //result: WWW
document.write(argumentsLike[1] + "
"); //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("
");
document.write(array.reverse().join("|")); //result: WWW|222|aaa

Eval Code
Variable Object就是調(diào)用eval時(shí)當(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 + "
"); \
        document.write(innerVar + "
"); \
');
    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中也可以訪問，因?yàn)樗鼈兊腣arible Object是同一個(gè)對(duì)象。
Scope/Scope Chain
首先Scope Chain是一個(gè)類似鏈表/堆棧的結(jié)構(gòu)，里面每個(gè)元素基本都是Variable Object/Activation Object。
其次存在執(zhí)行上下文的地方都有當(dāng)前Scope Chain，可以理解為Scope Chain就是執(zhí)行上下文的具體表現(xiàn)形式。
Global Code
Scope Chain只包含一個(gè)對(duì)象，即Global Object。在開始JavaScript代碼的執(zhí)行之前，引擎會(huì)創(chuàng)建好這個(gè)Scope Chain結(jié)構(gòu)。
Function Code
函數(shù)對(duì)象在內(nèi)部都有一個(gè)[[Scope]]屬性，用來記錄該函數(shù)所處位置的Scope Chain。
創(chuàng)建函數(shù)對(duì)象時(shí)，引擎會(huì)將當(dāng)前執(zhí)行環(huán)境的Scope Chain傳給Function的[[Construct]]方法。[[Construct]]會(huì)創(chuàng)建一個(gè)新的Scope Chain，內(nèi)容與傳入的Scope Chain完全一樣，并賦給被創(chuàng)建函數(shù)的內(nèi)部[[Scope]]屬性。在前面函數(shù)對(duì)象創(chuàng)建過程一節(jié)中，這個(gè)處理位于步驟4和5之間。
進(jìn)入函數(shù)調(diào)用時(shí)，也會(huì)創(chuàng)建一個(gè)新的Scope Chain，包括同一個(gè)函數(shù)的遞歸調(diào)用，退出函數(shù)時(shí)這個(gè)Scope Chain被丟棄。新建的Scope Chain第一個(gè)對(duì)象是Activation Object，接下來的內(nèi)容與內(nèi)部[[Scope]]上存儲(chǔ)的Scope Chain內(nèi)容完全一樣。
Eval Code
進(jìn)入Eval Code執(zhí)行時(shí)會(huì)創(chuàng)建一個(gè)新的Scope Chain，內(nèi)容與當(dāng)前執(zhí)行上下文的Scope Chain完全一樣。
實(shí)例說明
Scope Chain的原理就上面這些，必須結(jié)合JS代碼的執(zhí)行、Variable Instantiation的細(xì)節(jié)處理，才能理解上面這些如何產(chǎn)生作用，下面用一個(gè)簡(jiǎn)單的場(chǎng)景來綜合說明。假設(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即window對(duì)象，Variable Object為window對(duì)象本身。創(chuàng)建Scope Chain對(duì)象，假設(shè)為scope_1，其中只包含window對(duì)象。
2. 掃描JS源代碼(讀入源代碼、可能有詞法語法分析過程)，從結(jié)果中可以得到定義的變量名、函數(shù)對(duì)象。按照掃描順序:
   2.1 發(fā)現(xiàn)變量outerVar1，在window對(duì)象上添加outerVar1屬性，值為undefined；
   2.2 發(fā)現(xiàn)函數(shù)fn1的定義，使用這個(gè)定義創(chuàng)建函數(shù)對(duì)象，傳給創(chuàng)建過程的Scope Chain為scope_1。將結(jié)果添加到window的屬性中，名字為fn1，值為返回的函數(shù)對(duì)象。注意fn1的內(nèi)部[[Scope]]就是 scope_1。另外注意，創(chuàng)建過程并不會(huì)對(duì)函數(shù)體中的JS代碼做特殊處理，可以理解為只是將函數(shù)體JS代碼的掃描結(jié)果保存在函數(shù)對(duì)象的內(nèi)部屬性上，在函數(shù)執(zhí)行時(shí)再做進(jìn)一步處理。這對(duì)理解Function Code，尤其是嵌套函數(shù)定義中的Variable Instantiation很關(guān)鍵；
   2.3 發(fā)現(xiàn)變量outerVar2，在window對(duì)象上添加outerVar2屬性，值為undefined；
3. 執(zhí)行outerVar1賦值語句，賦值為"variable in global code"。
4. 執(zhí)行函數(shù)fn1，得到返回值:
   4.1 創(chuàng)建Activation Object，假設(shè)為activation_1；創(chuàng)建一個(gè)新的Scope Chain，假設(shè)為scope_2，scope_2中第一個(gè)對(duì)象為activation_1，第二個(gè)對(duì)象為window對(duì)象(取自fn1的 [[Scope]]，即scope_1中的內(nèi)容)；
   4.2 處理參數(shù)列表。在activation_1上設(shè)置屬性arg1、arg2，值分別為10、20。創(chuàng)建arguments對(duì)象并進(jìn)行設(shè)置，將arguments設(shè)置為activation_1的屬性；
   4.3 對(duì)fn1的函數(shù)體執(zhí)行類似步驟2的處理過程:
       4.3.1 發(fā)現(xiàn)變量innerVar1，在activation_1對(duì)象上添加innerVar1屬性，值為undefine；
       4.3.2 發(fā)現(xiàn)函數(shù)fn2的定義，使用這個(gè)定義創(chuàng)建函數(shù)對(duì)象，傳給創(chuàng)建過程的Scope Chain為scope_2(函數(shù)fn1的Scope Chain為當(dāng)前執(zhí)行上下文的內(nèi)容)。將結(jié)果添加到activation_1的屬性中，名字為fn2，值為返回的函數(shù)對(duì)象。注意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)建一個(gè)新的Scope Chain，假設(shè)為scope_3，scope_3中第一個(gè)對(duì)象為activation_2，接下來的對(duì)象依次為activation_1、window 對(duì)象(取自fn2的[[Scope]]，即scope_2)；
       4.5.2 處理參數(shù)列表。因?yàn)閒n2沒有參數(shù)，所以只用創(chuàng)建arguments對(duì)象并設(shè)置為activation_2的屬性。
       4.5.3 對(duì)fn2的函數(shù)體執(zhí)行類似步驟2的處理過程，沒有發(fā)現(xiàn)變量定義和函數(shù)聲明。
       4.5.4 執(zhí)行函數(shù)體。對(duì)任何一個(gè)變量引用，從scope_3上進(jìn)行搜索，這個(gè)示例中，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ù)上面的實(shí)例說明，就可以解釋下面這個(gè)測(cè)試代碼的結(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("
");
document.write(result2.exists + " " + result2.value); //result: true WWW

result1調(diào)用的地方，outerVar聲明和賦值的語句還沒有被執(zhí)行，但是測(cè)試結(jié)果window對(duì)象已經(jīng)擁有一個(gè)本地屬性outerVar，其值為undefined。result2的地方outerVar已經(jīng)賦值，所以window.outerVar的值已經(jīng)有了。實(shí)際使用中不要出現(xiàn)這種先使用，后定義的情況，否則某些情況下會(huì)有問題，因?yàn)闀?huì)涉及到一些規(guī)范中沒有提及，不同廠商實(shí)現(xiàn)方式上不一致的地方。
一些特殊處理
1. with(obj) { ... }這個(gè)語法的實(shí)現(xiàn)方式，是在當(dāng)前的Scope Chain最前面位置插入obj這個(gè)對(duì)象，這樣就會(huì)先在obj上搜索是否有相應(yīng)名字的屬性存在。其它類似的還有catch語句。
2. 前面對(duì)arguments對(duì)象的詳細(xì)說明中，提到了對(duì)函數(shù)遞歸調(diào)用的支持問題，了解到了匿名函數(shù)使用arguments.callee來實(shí)現(xiàn)引用自己，而命名函數(shù)可以在函數(shù)體內(nèi)引用自己，根據(jù)上面Scope Chain的工作原理我們還無法解釋這個(gè)現(xiàn)象，因?yàn)檫@里有個(gè)特殊處理。
任何時(shí)候創(chuàng)建一個(gè)命名函數(shù)對(duì)象時(shí)，JavaScript引擎會(huì)在當(dāng)前執(zhí)行上下文Scope Chain的最前面插入一個(gè)對(duì)象，這個(gè)對(duì)象使用new Object()方式創(chuàng)建，并將這個(gè)Scope Chain傳給Function的構(gòu)造函數(shù)[[Construct]]，最終創(chuàng)建出來的函數(shù)對(duì)象內(nèi)部[[Scope]]上將包含這個(gè)object對(duì)象。創(chuàng)建過程返回之后，JavaScript引擎在object上添加一個(gè)屬性，名字為函數(shù)名，值為返回的函數(shù)對(duì)象，然后從當(dāng)前執(zhí)行上下文的Scope Chain中移除它。這樣函數(shù)對(duì)象的Scope Chain中第一個(gè)對(duì)象就是對(duì)自己的引用，而移除操作則確保了對(duì)函數(shù)對(duì)象創(chuàng)建處Scope Chain的恢復(fù)。
this關(guān)鍵字處理
執(zhí)行上下文包含的另一個(gè)概念是this關(guān)鍵字。
Global Code中this關(guān)鍵字為Global Object；函數(shù)調(diào)用時(shí)this關(guān)鍵字為調(diào)用者，例如obj1.fn1()，在fn1中this對(duì)象為obj1；Eval Code中this關(guān)鍵字為當(dāng)前執(zhí)行上下文的Variable Object。
在函數(shù)調(diào)用時(shí)，JavaScript提供一個(gè)讓用戶自己指定this關(guān)鍵字值的機(jī)會(huì)，即每個(gè)函數(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ù)組的方式提供各個(gè)參數(shù)，而call方法必須一個(gè)一個(gè)參數(shù)的給。
前面的測(cè)試示例代碼中有多處運(yùn)用到了這個(gè)方法。例如window對(duì)象并沒有 hasOwnProperty方法，使用Object.prototype.hasOwnProperty.call(window, "propertyName")也可以測(cè)試它是否擁有某個(gè)本地屬性。
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返回的是一個(gè)內(nèi)嵌函數(shù)，內(nèi)嵌函數(shù)使用了outer的局部變量a和b。照理outer的局部變量在返回時(shí)就超出了作用域因此inner() 調(diào)用無法使用才對(duì)。這就是閉包Closure，即函數(shù)調(diào)用返回了一個(gè)內(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)造它時(shí)的Scope Chain，雖然outer返回導(dǎo)致這些對(duì)象超出了作用域、生存期范圍，但JavaScript使用自動(dòng)垃圾回收來釋放對(duì)象內(nèi)存: 按照規(guī)則定期檢查，對(duì)象沒有任何引用才被釋放。因此上面的代碼能夠正確運(yùn)行。