javascript prototype 原型鏈

JavaScript中的prototype概念恰如其分地反映了這個詞的內含，我們不能將其理解為C++的prototype那種預先聲明的概念。
JavaScript 的所有function類型的對象都有一個prototype屬性。這個prototype屬性本身又是一個object類型的對象，因此我們也可以給這個prototype對象添加任意的屬性和方法。既然prototype是對象的“原型”，那麼由該函數構造出來的對象應該都會具有這個“原型”的特性。事實上，在建構函式的prototype上定義的所有屬性和方法，都是可以通過其構造的對象直接存取和調用的。也可以這麼說，prototype提供了一群同類對象共用屬性和方法的機制。
我們先來看看下面的代碼：
function Person(name)
{
this.name = name; //設定對象屬性，每個對象各自一份屬性資料
};
Person.prototype.SayHello = function() //給Person函數的prototype添加SayHello方法。
{
alert("Hello, I'm " + this.name);
}
var BillGates = new Person("Bill Gates"); //建立BillGates對象
var SteveJobs = new Person("Steve Jobs"); //建立SteveJobs對象
BillGates.SayHello(); //通過BillGates對象直接調用到SayHello方法
SteveJobs.SayHello(); //通過SteveJobs對象直接調用到SayHello方法
alert(BillGates.SayHello == SteveJobs.SayHello); //因為兩個對象是共用prototype的SayHello，所以顯示：true
程式啟動並執行結果表明，建構函式的prototype上定義的方法確實可以通過對象直接調用到，而且代碼是共用的。顯然，把方法設定到prototype的寫法顯得優雅多了，儘管調用形式沒有變，但邏輯上卻體現了方法與類的關係，相對前面的寫法，更容易理解和組織代碼。
那麼，對於多層次類型的建構函式情況又如何呢？
我們再來看下面的代碼：
1 function Person(name) //基類建構函式
2 {
3 this.name = name;
4 };
5
6 Person.prototype.SayHello = function() //給基類建構函式的prototype添加方法
7 {
8 alert("Hello, I'm " + this.name);
9 };
10
11 function Employee(name, salary) //子類建構函式
12 {
13 Person.call(this, name); //調用基類建構函式
14 this.salary = salary;
15 };
16
17 Employee.prototype = new Person(); //建一個基類的對象作為子類原型的原型，這裡很有意思
18
19 Employee.prototype.ShowMeTheMoney = function() //給子類添建構函式的prototype添加方法
20 {
21 alert(this.name + " $" + this.salary);
22 };
23
24 var BillGates = new Person("Bill Gates"); //建立基類Person的BillGates對象
25 var SteveJobs = new Employee("Steve Jobs", 1234); //建立子類Employee的SteveJobs對象
26
27 BillGates.SayHello(); //通過對象直接調用到prototype的方法
28 SteveJobs.SayHello(); //通過子類對象直接調用基類prototype的方法，關注！
29 SteveJobs.ShowMeTheMoney(); //通過子類對象直接調用子類prototype的方法
30
31 alert(BillGates.SayHello == SteveJobs.SayHello); //顯示：true，表明prototype的方法是共用的
這段代碼的第17行，構造了一個基類的對象，並將其設為子類建構函式的prototype，這是很有意思的。這樣做的目的就是為了第28行，通過子類對象也可以直接調用基類prototype的方法。為什麼可以這樣呢？
原來，在JavaScript中，prototype不但能讓對象共用自己財富，而且prototype還有尋根問祖的天性，從而使得先輩們的遺產可以代代相傳。當從一個對象那裡讀取屬性或調用方法時，如果該對象自身不存在這樣的屬性或方法，就會去自己關聯的prototype對象那裡尋找；如果 prototype沒有，又會去prototype自己關聯的前輩prototype那裡尋找，直到找到或追溯過程結束為止。
在 JavaScript內部，對象的屬性和方法追溯機制是通過所謂的prototype鏈來實現的。當用new操作符構造對象時，也會同時將建構函式的 prototype對象指派給新建立的對象，成為該對象內建的原型對象。對象內建的原型對象應該是對外不可見的，儘管有些瀏覽器(如Firefox)可以讓我們訪問這個內建原型對象，但並不建議這樣做。內建的原型對象本身也是對象，也有自己關聯的原型對象，這樣就形成了所謂的原型鏈。
在原型鏈的最末端，就是Object建構函式prototype屬性指向的那一個原型對象。這個原型對象是所有對象的最老祖先，這個老祖宗實現了諸如 toString等所有對象天生就該具有的方法。其他內建建構函式，如Function, Boolean, String, Date和RegExp等的prototype都是從這個老祖宗傳承下來的，但他們各自又定義了自身的屬性和方法，從而他們的子孫就表現出各自宗族的那些特徵。
這不就是“繼承”嗎？是的，這就是“繼承”，是JavaScript特有的“原型繼承”。
“ 原型繼承”是慈祥而又嚴厲的。原形對象將自己的屬性和方法無私地貢獻給孩子們使用，也並不強迫孩子們必須遵從，允許一些頑皮孩子按自己的興趣和愛好獨立行事。從這點上看，原型對象是一位慈祥的母親。然而，任何一個孩子雖然可以我行我素，但卻不能動原型對象既有的財產，因為那可能會影響到其他孩子的利益。從這一點上看，原型對象又象一位嚴厲的父親。我們來看看下面的代碼就可以理解這個意思了：
function Person(name)
{
this.name = name;
};
Person.prototype.company = "Microsoft"; //原型的屬性
Person.prototype.SayHello = function() //原型的方法
{
alert("Hello, I'm " + this.name + " of " + this.company);
};
var BillGates = new Person("Bill Gates");
BillGates.SayHello(); //由於繼承了原型的東西，規規矩矩輸出：Hello, I'm Bill Gates
var SteveJobs = new Person("Steve Jobs");
SteveJobs.company = "Apple"; //設定自己的company屬性，掩蓋了原型的company屬性
SteveJobs.SayHello = function() //實現了自己的SayHello方法，掩蓋了原型的SayHello方法
{
alert("Hi, " + this.name + " like " + this.company + ", ha ha ha ");
};
SteveJobs.SayHello(); //都是自己覆蓋的屬性和方法，輸出：Hi, Steve Jobs like Apple, ha ha ha
BillGates.SayHello(); //SteveJobs的覆蓋沒有影響原型對象，BillGates還是按老樣子輸出
對象可以掩蓋原型對象的那些屬性和方法，一個建構函式原型對象也可以掩蓋上層建構函式原型對象既有的屬性和方法。這種掩蓋其實只是在對象自己身上建立了新的屬性和方法，只不過這些屬性和方法與原型對象的那些同名而已。JavaScript就是用這簡單的掩蓋機制實現了對象的“多態”性，與靜態對象語言的虛函數和重載(override)概念不謀而合。
然而，比靜態對象語言更神奇的是，我們可以隨時給原型對象動態添加新的屬性和方法，從而動態地擴充基類的功能特性。這在靜態對象語言中是很難想象的。我們來看下面的代碼：
function Person(name)
{
this.name = name;
};
Person.prototype.SayHello = function() //建立對象前定義的方法
{
alert("Hello, I'm " + this.name);
};
var BillGates = new Person("Bill Gates"); //建立對象
BillGates.SayHello();
Person.prototype.Retire = function() //建立對象後再動態擴充原型的方法
{
alert("Poor " + this.name + ", bye bye!");
};
BillGates.Retire(); //動態擴充的方法即可被先前建立的對象立即調用
阿彌佗佛，原型繼承竟然可以玩出有這樣的法術！
原型擴充
想必君的悟性極高，可能你會這樣想：如果在JavaScript內建的那些如Object和Function等函數的prototype上添加些新的方法和屬性，是不是就能擴充JavaScript的功能呢？
那麼，恭喜你，你得到了！
在 AJAX技術迅猛發展的今天，許多成功的AJAX項目的JavaScript運行庫都大量擴充了內建函數的prototype功能。比如微軟的 ASP.NET AJAX，就給這些內建函數及其prototype添加了大量的新特性，從而增強了JavaScript的功能。
我們來看一段摘自MicrosoftAjax.debug.js中的代碼：
String.prototype.trim = function String$trim() {
if (arguments.length !== 0) throw Error.parameterCount();
return this.replace(/^\s+|\s+$/g, '');
}
這段代碼就是給內建String函數的prototype擴充了一個trim方法，於是所有的String類對象都有了trim方法了。有了這個擴充，今後要去除字串兩段的空白，就不用再分別處理了，因為任何字串都有了這個擴充功能，只要調用即可，真的很方便。
當然，幾乎很少有人去給Object的prototype添加方法，因為那會影響到所有的對象，除非在你的架構中這種方法的確是所有對象都需要的。
前兩年，微軟在設計AJAX類庫的初期，用了一種被稱為“閉包”(closure)的技術來類比“類”。其大致模型如下：
function Person(firstName, lastName, age)
{
//私人變數：
var _firstName = firstName;
var _lastName = lastName;
//公開變數:
this.age = age;
//方法：
this.getName = function()
{
return(firstName + " " + lastName);
};
this.SayHello = function()
{
alert("Hello, I'm " + firstName + " " + lastName);
};
};
var BillGates = new Person("Bill", "Gates", 53);
var SteveJobs = new Person("Steve", "Jobs", 53);
BillGates.SayHello();
SteveJobs.SayHello();
alert(BillGates.getName() + " " + BillGates.age);
alert(BillGates.firstName); //這裡不能訪問到私人變數
很顯然，這種模型的類描述特別象C#語言的描述形式，在一個建構函式裡依次定義了私人成員、公用屬性和可用的方法，顯得非常優雅嘛。特別是“閉包”機制可以類比對私人成員的保護機制，做得非常漂亮。
所謂的“閉包”，就是在建構函式體內定義另外的函數作為目標對象的方法函數，而這個對象的方法函數反過來引用外層外層函數體中的臨時變數。這使得只要目標對象在生存期內始終能保持其方法，就能間接保持原建構函式體當時用到的臨時變數值。儘管最開始的建構函式調用已經結束，臨時變數的名稱也都消失了，但在目標對象的方法內卻始終能引用到該變數的值，而且該值只能通這種方法來訪問。即使再次調用相同的建構函式，但只會產生新對象和方法，新的臨時變數只是對應新的值，和上次那次調用的是各自獨立的。的確很巧妙！
但是前面我們說過，給每一個對象設定一份方法是一種很大的浪費。還有，“閉包”這種間接保持變數值的機制，往往會給JavaSript的記憶體回收行程製造難題。特別是遇到對象間複雜的循環參考時，記憶體回收的判斷邏輯非常複雜。無專屬偶，IE瀏覽器早期版本確實存在JavaSript記憶體回收方面的記憶體流失問題。再加上“閉包”模型在效能測試方面的表現不佳，微軟最終放棄了“閉包” 模型，而改用“原型”模型。正所謂“有得必有失”嘛。
原型模型需要一個建構函式來定義對象的成員，而方法卻依附在該建構函式的原型上。大致寫法如下：
//定義建構函式
function Person(name)
{
this.name = name; //在建構函式中定義成員
};
//方法定義到建構函式的prototype上
Person.prototype.SayHello = function()
{
alert("Hello, I'm " + this.name);
};
//子類建構函式
function Employee(name, salary)
{
Person.call(this, name); //調用上層建構函式
this.salary = salary; //擴充的成員
};
//子類建構函式首先需要用上層建構函式來建立prototype對象，實現繼承的概念
Employee.prototype = new Person() //只需要其prototype的方法，此對象的成員沒有任何意義！
//子類方法也定義到建構函式之上
Employee.prototype.ShowMeTheMoney = function()
{
alert(this.name + " $" + this.salary);
};
var BillGates = new Person("Bill Gates");
BillGates.SayHello();
var SteveJobs = new Employee("Steve Jobs", 1234);
SteveJobs.SayHello();
SteveJobs.ShowMeTheMoney();
原型類模型雖然不能類比真正的私人變數，而且也要分兩部分來定義類，顯得不怎麼“優雅”。不過，對象間的方法是共用的，不會遇到記憶體回收問題，而且效能優於“閉包”模型。正所謂“有失必有得”嘛。
在原型模型中，為了實作類別繼承，必須首先將子類建構函式的prototype設定為一個父類的對象執行個體。建立這個父類對象執行個體的目的就是為了構成原型鏈，以起到共用上層原型方法作用。但建立這個執行個體對象時，上層建構函式也會給它設定對象成員，這些對象成員對於繼承來說是沒有意義的。雖然，我們也沒有給建構函式傳遞參數，但確實建立了若干沒有用的成員，儘管其值是undefined，這也是一種浪費啊。
唉！世界上沒有完美的事情啊！
原型真諦
正當我們感概萬分時，天空中一道紅光閃過，祥雲中出現了觀音菩薩。只見她手持玉淨瓶，輕拂翠柳枝，灑下幾滴甘露，頓時讓JavaScript又添新的靈氣。
觀音灑下的甘露在JavaScript的世界裡凝結成塊，成為了一種稱為“文法甘露”的東西。這種文法甘露可以讓我們編寫的代碼看起來更象對象語言。
要想知道這“文法甘露”為何物，就請君側耳細聽。
在理解這些文法甘露之前，我們需要重新再回顧一下JavaScript構造對象的過程。
我們已經知道，用 var anObject = new aFunction() 形式建立對象的過程實際上可以分為三步：第一步是建立一個新對象；第二步將該對象內建的原型對象設定為建構函式prototype引用的那個原型對象；第三步就是將該對象作為this參數調用建構函式，完成成員設定等初始化工作。對象建立之後，對象上的任何訪問和操作都只與對象自身及其原型鏈上的那串對象有關，與建構函式再扯不上關係了。換句話說，建構函式只是在建立對象時起到介紹原型對象和初始化對象兩個作用。
那麼，我們能否自己定義一個對象來當作原型，並在這個原型上描述類，然後將這個原型設定給新建立的對象，將其當作對象的類呢？我們又能否將這個原型中的一個方法當作建構函式，去初始化建立的對象呢？例如，我們定義這樣一個原型對象：
var Person = //定義一個對象來作為原型類
{
Create: function(name, age) //這個當建構函式
{
this.name = name;
this.age = age;
},
SayHello: function() //定義方法
{
alert("Hello, I'm " + this.name);
},
HowOld: function() //定義方法
{
alert(this.name + " is " + this.age + " years old.");
}
};
這個JSON形式的寫法多麼象一個C#的類啊！既有建構函式，又有各種方法。如果可以用某種形式來建立對象，並將對象的內建的原型設定為上面這個“類”對象，不就相當於建立該類的對象了嗎？
但遺憾的是，我們幾乎不能訪問到對象內建的原型屬性！儘管有些瀏覽器可以訪問到對象的內建原型，但這樣做的話就只能限定了使用者必須使用那種瀏覽器。這也幾乎不可行。
那麼，我們可不可以通過一個函數對象來做媒介，利用該函數對象的prototype屬性來中轉這個原型，並用new操作符傳遞給建立的對象呢？
其實，象這樣的代碼就可以實現這一目標：
function anyfunc(){}; //定義一個函數軀殼
anyfunc.prototype = Person; //將原型對象放到中轉站prototype
var BillGates = new anyfunc(); //建立對象的內建原型將是我們期望的原型對象
不過，這個anyfunc函數只是一個軀殼，在使用過這個軀殼之後它就成了多餘的東西了，而且這和直接使用建構函式來建立對象也沒啥不同，有點不爽。
可是，如果我們將這些代碼寫成一個通用函數，而那個函數軀殼也就成了函數內的函數，這個內建函式不就可以在外層函數退出範圍後自動消亡嗎？而且，我們可以將原型對象作為通用函數的參數，讓通用函數返回建立的對象。我們需要的就是下面這個形式：
function New(aClass, aParams) //通用建立函數
{
function new_() //定義臨時的中轉函數殼
{
aClass.Create.apply(this, aParams); //調用原型中定義的的建構函式，中轉構造邏輯及構造參數
};
new_.prototype = aClass; //準備中轉原型對象
return new new_(); //返回建立最終建立的對象
};
var Person = //定義的類
{
Create: function(name, age)
{
this.name = name;
this.age = age;
},
SayHello: function()
{
alert("Hello, I'm " + this.name);
},
HowOld: function()
{
alert(this.name + " is " + this.age + " years old.");
}
};
var BillGates = New(Person, ["Bill Gates", 53]); //調用通用函數建立對象，並以數組形式傳遞構造參數
BillGates.SayHello();
BillGates.HowOld();
alert(BillGates.constructor == Object); //輸出：true
這裡的通用函數New()就是一個“文法甘露”！這個文法甘露不但中轉了原型對象，還中轉了建構函式邏輯及構造參數。
有趣的是，每次建立完對象退出New函數範圍時，臨時的new_函數對象會被自動釋放。由於new_的prototype屬性被設定為新的原型對象，其原來的原型對象和new_之間就已解開了引用鏈，臨時函數及其原來的原型對象都會被正確回收了。上面代碼的最後一句證明，新建立的對象的 constructor屬性返回的是Object函數。其實建立的對象自己及其原型裡沒有constructor屬性，那返回的只是最頂層原型對象的建構函式，即Object。
有了New這個文法甘露，類的定義就很像C#那些靜態對象語言的形式了，這樣的代碼顯得多麼文靜而優雅啊！
當然，這個代碼僅僅展示了“文法甘露”的概念。我們還需要多一些的文法甘露，才能實現用簡潔而優雅的代碼書寫類層次及其繼承關係。好了，我們再來看一個更豐富的樣本吧：
//文法甘露：
var object = //定義小寫object基本類，用於實現最基礎的方法等
{
isA: function(aType) //一個判斷類與類之間以及對象與類之間關係的基礎方法
{
var self = this;
while(self)
{
if (self == aType)
return true;
self = self.Type;
};
return false;
}
};
function Class(aBaseClass, aClassDefine) //建立類的函數，用於聲明類及繼承關係
{
function class_() //建立類的臨時函數殼
{
this.Type = aBaseClass; //我們給每一個類約定一個Type屬性，引用其繼承的類
for(var member in aClassDefine)
this[member] = aClassDefine[member]; //複製類的全部定義到當前建立的類
};
class_.prototype = aBaseClass;
return new class_();
};
function New(aClass, aParams) //建立對象的函數，用於任意類的對象建立
{
function new_() //建立對象的臨時函數殼
{
this.Type = aClass; //我們也給每一個對象約定一個Type屬性，據此可以訪問到對象所屬的類
if (aClass.Create)
aClass.Create.apply(this, aParams); //我們約定所有類的建構函式都叫Create，這和DELPHI比較相似
};
new_.prototype = aClass;
return new new_();
};
//文法甘露的應用效果：
var Person = Class(object, //派生至object基本類
{
Create: function(name, age)
{
this.name = name;
this.age = age;
},
SayHello: function()
{
alert("Hello, I'm " + this.name + ", " + this.age + " years old.");
}
});
var Employee = Class(Person, //派生至Person類，是不是和一般對象語言很相似？
{
Create: function(name, age, salary)
{
Person.Create.call(this, name, age); //調用基類的建構函式
this.salary = salary;
},
ShowMeTheMoney: function()
{
alert(this.name + " $" + this.salary);
}
});
var BillGates = New(Person, ["Bill Gates", 53]);
var SteveJobs = New(Employee, ["Steve Jobs", 53, 1234]);
BillGates.SayHello();
SteveJobs.SayHello();
SteveJobs.ShowMeTheMoney();
var LittleBill = New(BillGates.Type, ["Little Bill", 6]); //根據BillGate的類型建立LittleBill
LittleBill.SayHello();
alert(BillGates.isA(Person)); //true
alert(BillGates.isA(Employee)); //false
alert(SteveJobs.isA(Person)); //true
alert(Person.isA(Employee)); //false
alert(Employee.isA(Person)); //true
“文法甘露”不用太多，只要那麼一點點，就能改觀整個代碼的易讀性和流暢性，從而讓代碼顯得更優雅。有了這些文法甘露，JavaScript就很像一般對象語言了，寫起代碼了感覺也就爽多了！
令人高興的是，受這些甘露滋養的JavaScript程式效率會更高。因為其原型對象裡既沒有了毫無用處的那些對象級的成員，而且還不存在 constructor屬性體，少了與建構函式間的牽連，但依舊保持了方法的共用性。這讓JavaScript在追溯原型鏈和搜尋屬性及方法時，少費許多工夫啊。
我們就把這種形式稱為“甘露模型”吧！其實，這種“甘露模型”的原型用法才是符合prototype概念的本意，才是的JavaScript原型的真諦！
想必微軟那些設計AJAX架構的工程師看到這個甘露模型時，肯定後悔沒有早點把AJAX部門從美國搬到咱中國的觀音廟來，錯過了觀音菩薩的點化。當然，我們也只能是在代碼的樣本中，把Bill Gates當作對象玩玩，真要讓他放棄上帝轉而皈依我佛肯定是不容易的，機緣未到啊！如果哪天你在微軟新出的AJAX類庫中看到這種甘露模型，那才是真正的緣分！
編程的快樂
在軟體工業迅猛發展的今天，各式各樣的程式設計語言層出不窮，新語言的誕生，舊語言的演化，似乎已經讓我們眼花繚亂。為了適應物件導向編程的潮流，JavaScript語言也在向完全物件導向的方向發展，新的JavaScript標準已經從語義上擴充了許多物件導向的新元素。與此相反的是，許多靜態對象語言也在向JavaScript的那種簡潔而幽雅的方向發展。例如，新版本的C#語言就吸收了JSON那樣的簡潔標記法，以及一些其他形式的JavaScript特性。
我們應該看到，隨著RIA(強互聯應用)的發展和普及，AJAX技術也將逐漸淡出江湖，JavaScript也將最終消失或演化成其他形式的語言。但不管程式設計語言如何發展和演化，編程世界永遠都會在“資料”與“代碼”這千絲萬縷的糾纏中保持著無限的生機。只要我們能看透這一點，我們就能很容易地學習和理解軟體世界的各種新事物。不管是已熟悉的過程式編程，還是正在發展的函數式編程，以及未來量子糾纏態的大規模並行式編程，我們都有足夠的法力來化解一切複雜的難題。