JavaScript中所有函式都有一個 prototype 屬性,而這個屬性是一個物件。所有由該函式建構出來的物件,都具備這個 prototype 上的特性——也就是說,可以直接透過實體存取 prototype 上的屬性與方法。
function Staff(name) {
this.name = name;
}
Staff.prototype.say = function () {
alert(this.name + " say hello");
}
var staff1 = new Staff("hunter");
var staff2 = new Staff("dangjian");
staff1.say();
staff2.say();
執行結果顯示,prototype 上的屬性與方法可以透過建構出的物件呼叫。更重要的是,這些屬性與方法在同類型的物件之間是共享的:
alert(staff1.say == staff2.say); // true
兩者指向同一個函式物件,這與每個實體各自擁有一份副本的做法有本質差異。
把基類的實體指派給子類的 prototype,就能模擬物件導向中的繼承:
function Staff(name) { // 基類
this.name = name;
}
Staff.prototype.say = function () {
alert(this.name + " say hello");
}
function ManStaff(name, age) { // 子類
this.name = name;
this.age = age;
}
ManStaff.prototype = new Staff(); // 建立繼承關係
var manStaff1 = new ManStaff("hunter", 22);
var manStaff2 = new ManStaff("dangjian", 32);
manStaff1.say();
manStaff2.say();
執行後可以確認,ManStaff 的實體具備了基類 Staff 的 say 方法。這種繼承是透過原型鏈實作的。
上面這些用法很多人已經熟悉,但身為工程師,不能只知道怎麼用,更該理解背後的機制。以下就來拆解 prototype 的原理與原型鏈的建構過程。
理解 prototype 機制的前提,是理解JavaScript中函式的建立方式。
當程式執行到 function Staff(name) { this.name = name; } 時,相當於執行:
var Staff = new Function("name", "this.name = name");
解譯器會使用預先定義好的 Function() 建構器,建立一個函式型別的物件,也就是 Staff。
接著,會為建立好的 Staff 物件加上 __proto__ 屬性,並指派為 Function 建構器的 prototype:
Staff.__proto__ = Function.prototype;
這一步是所有物件建立過程都有的步驟。執行類似 var x = new X() 時,都會把 X 的 prototype 指派給 x 的 __proto__。
然後,會為 Staff 建立 prototype 屬性——這一步是函式型別的物件才有的。過程可以寫成:
var o = new Object(); o.constructor = Base; Staff.prototype = o;
小結:建立物件時會產生私有屬性 __proto__;建立函式時會額外產生 prototype 屬性。由於 Staff 是函式型別的物件,它同時具備這兩個屬性——這正是建構原型鏈的關鍵。
來看 var staff1 = new Staff("hunter") 這行。根據上面的分析:
staff1.__proto__ = Staff.prototype;
而 Staff.prototype 是一個由 Object 建立的物件,所以:
Staff.prototype.__proto__ = Object.prototype; // 因此 staff1.__proto__.__proto__ == Object.prototype;
這條串接起來的鏈就是原型鏈。當要讀取某個物件的屬性時,JavaScript會先找物件本身有沒有這個屬性,沒有就沿著原型鏈一路往上找。
既然原型鏈的頂端都是 Object.prototype,那就意味著在繼承關係中 Object 是所有物件的基類。可以這樣驗證:
Object.prototype.location = "China";
function Staff(name) {
this.name = name;
}
Staff.prototype.say = function () {
alert(this.name + " say hello");
}
var ManStaff1 = new Staff("hunter");
var ManStaff2 = new Staff("dangjian");
alert(ManStaff1.location); // China
alert(ManStaff2.location); // China
結果印證了這個推論。理解了函式的建立原理,要建構 Staff 的子類就水到渠成:
function Staff(name) { // 基類
this.name = name;
}
Staff.prototype.say = function () {
alert(this.name + " say hello");
}
function ManStaff(name, age) { // 子類
Staff.call(this, name); // 借用基類建構器初始化
this.age = age;
}
ManStaff.prototype = new Staff(); // 建立繼承關係
var ManStaff1 = new ManStaff("hunter", 22);
var ManStaff2 = new ManStaff("dangjian", 32);
ManStaff1.say();
ManStaff2.say();
關鍵就在這一句:ManStaff.prototype = new Staff();。整條鏈的推算過程是:
ManStaff1.__proto__ == ManStaff.prototype ManStaff.prototype.__proto__ == Staff.prototype Staff.prototype.__proto__ == Object.prototype // 所以 ManStaff1.__proto__.__proto__.__proto__ == Object.prototype
另外要注意 Staff.call(this, name) 這行的作用。單靠 ManStaff.prototype = new Staff() 只能繼承到原型上的方法,基類在建構器中設立的實體屬性並不會自動複製過來。用 call 把基類建構器「借」到目前物件上執行,才能讓 this.name 正確設定。這兩步搭配,才算完整的繼承實作。
JavaScript的這種繼承關係比傳統物件導向的類別繼承更松散,建構方式也較難理解。但作為一種腳本語言,這套機制已經足夠強大——它用極少的語法元素(函式 + 物件 + 屬性查找)就撐起了完整的物件導向能力。
補充一點現況:ES6 引入了 class 與 extends 語法,本質上仍是原型繼承的語法糖,但可讀性提升許多。同時 Object.create() 也提供了更直接的「以某物件為原型建立新物件」的方式。理解原型鏈的運作原理,正是讀懂這些語法糖背後所發生之事的基礎。