最基礎的方式,與多數語言相同:沒物件,new 一個就好。
var gf = new Object();
gf.name = "tangwei";
gf.bar = "c++";
gf.sayWhat = function() {
console.log(this.name + " said: love you forever");
};
這樣似乎夠了,但 geek 們不會滿足於如此冗長的寫法。作為一門腳本語言,理該有更俐落的姿態,於是有了物件字面量:
var gf = {
name: "tangwei",
bar: "c++",
sayWhat: function() {
console.log(this.name + " said: love you forever");
}
};
實務中最常用到的場景是「我要產生一堆屬性結構相似的物件」。若一個一個定義,程式碼會迅速膨脹,不如蓋一座工廠批量生產:
function createGf(name, bar) {
var o = new Object();
o.name = name;
o.bar = bar;
o.sayWhat = function() {
alert(this.name + " said: love you forever");
};
return o;
}
var gf1 = createGf("bingbing", "d");
var gf2 = createGf("mimi", "a");
工廠模式解決了多個相似物件的建立問題,但新問題是:這些物件全是 Object 做出來的,該怎麼區分它們的具體型別?
function Gf(name, bar){
this.name = name;
this.bar = bar;
this.sayWhat = function(){
alert(this.name + " said: love you forever");
};
}
var gf1 = new Gf("vivian", "f");
var gf2 = new Gf("vivian2", "f");
這裡改用大寫開頭的建構函數(慣例如此)取代 createGf:建立一個新物件,把建構函數的作用域指派給它,再執行建構函數中的程式碼。這個做法讓每個物件都有明確的型別歸屬。
但仔細看會發現一個浪費:兩個實例呼叫的 sayWhat 並不是同一個 Function 實例:
console.log(gf1.sayWhat == gf2.sayWhat); // false
呼叫同一個方法卻各自建立一份實例,明顯浪費資源。直覺的解法是把 sayWhat 移到建構函數外面宣告:
function Gf(name, bar){
this.name = name;
this.bar = bar;
this.sayWhat = sayWhat;
}
function sayWhat(){
alert(this.name + " said: love you forever");
}
問題解決了,但新問題又來:這個 sayWhat 是全域函數,實際上並不適合成為全域資產,某種程度上顯得矛盾——它明明只服務 Gf。想要優雅地定義一個具備封裝性的物件,就得看原型物件模式。
建立一個函數時,該函數會具備一個 prototype 屬性,指向「透過此建構函數建立的那些物件所共享的原型物件」。通俗地說,原型物件就是記憶體中為其他物件提供共用屬性與方法的物件。

在原型模式中,不必在建構函數裡定義屬性,直接把資訊掛到原型上即可:
function Gf(){}
Gf.prototype.name = "vivian";
Gf.prototype.bar = "c++";
Gf.prototype.sayWhat = function(){
alert(this.name + " said: love you forever");
};
var gf1 = new Gf();
gf1.sayWhat();
var gf2 = new Gf();
與建構函數不同,這裡的屬性與方法由所有實例共享——gf1 與 gf2 存取的是同一份。除了我們掛上去的屬性,原型物件還有內建的 constructor,它是一個指向「擁有該 prototype 屬性的函數」的指標。整理成流程如下:

所有物件都有一個原型物件;原型物件上的 constructor 指回包含它的函數;Gf 的實例 gf1 與 gf2 各自有一個內部連結指向原型(Firefox 中表現為私有屬性 __proto__)。當我們存取某個屬性時,引擎先問實例本身有沒有,沒有就沿著連結往原型找——這就是屬性查找的基本順序。
每次都寫 Gf.prototype.xxx 相當累贅,可以改用字面量一次定義:
function Gf(){}
Gf.prototype = {
name: "vivian",
bar: "c++",
sayWhat: function(){
alert(this.name + " said: love you forever");
}
};
這裡有個容易忽略的細節:constructor 不再指向 Gf。因為每定義一個函數,引擎會自動為它建立 prototype 並掛上 constructor;而我們用字面量整個覆寫了 prototype,新字面量並沒有 constructor,於是會沿原型鏈找到 Object.prototype.constructor:
var gf1 = new Gf(); console.log(gf1.constructor == Gf); // false console.log(gf1.constructor == Object); // true
一般情況下這個微妙變化不影響任何功能,但若程式碼依賴 constructor 做型別判斷,就必須手動補回:
Gf.prototype = {
constructor: Gf,
name: "vivian",
bar: "c++",
sayWhat: function() {
alert(this.name + " said: love you forever");
}
};
var gf1 = new Gf();
console.log(gf1.constructor == Gf); // true
說到底,原型模式的基本特點就是「所有實例共用同一份屬性」,這對開發者是一把雙面刃:我們通常希望每個實例擁有自己的資料。這也正是實務上很少單獨使用原型模式的主要原因。
標準解法是把兩者放在一起:用建構函數定義實例各自的屬性,用原型定義共用的方法:
function Gf(name, bar){
this.name = name;
this.bar = bar;
}
Gf.prototype = {
constructor: Gf,
sayWhat: function() {
alert(this.name + " said: love you forever");
}
};
var gf1 = new Gf("vivian", "f");
var gf2 = new Gf("vivian1", "c");
屬性在構造函數中各自定義,因此 gf1 與 gf2 互不影響;sayWhat 掛在原型上,所有實例共用同一份函數,既省記憶體也便於集中維護。這是實務上最常用的物件定義方式,包括 jQuery 插件、Bootstrap 等許多早期函式庫的元件建構,走的都是這條路。
補充一句現況:ES6 的 class 語法本質上就是這套組合模式的標準化寫法——constructor 裡的賦值對應實例屬性,方法宣告則自動掛到 prototype 上,因此不需要再手動處理 constructor 指向的問題。理解原型的存在,才能在遇到「為什麼改了原型,所有實例都變了」這類問題時迅速定位。