JavaScript 雖然是一門物件導向語言,卻沒有 class 的概念——一切都是物件,而每個物件都是某個參照類型的實例。如何在這套規則下優雅地建立物件,就衍生出多種模式。
物件字面量、工廠模式、建構函式模式、原型模式、建構函式與原型組合、動態原型模式。以下逐一剖析,並說明各自的問題所在。
var person = {
name: 'Nicholas',
age: '22',
job: "software Engineer",
sayName: function () {
alert(this.name);
}
};
建立了一個名為 person 的物件,加上三個屬性與一個方法,其中 sayName() 用於顯示 this.name 的值。
明顯缺點:用同一個介面建立大量物件時,會產生大量重複程式碼。
工廠模式是軟體工程領域廣為人知的設計模式,它用函式封裝了「建立具體物件」的細節。
function createPerson(name, age, job) {
var o = new Object();
o.name = name;
o.age = age;
o.job = job;
o.sayName = function () {
alert(this.name);
};
return o;
}
var person1 = createPerson("Nicholas", 22, "software Engineer");
var person2 = createPerson("Greg", 24, "student");
createPerson 函式能依傳入參數建構出包含所有必要資訊的物件,可以無限次呼叫,每次都回傳一個含三個屬性與一個方法的新物件。
工廠模式解決了「建立多個相似物件」的問題,卻沒有解決物件識別的問題——也就是說,我們無從得知一個物件的型別。
function Person(name, age, job) {
this.name = name;
this.age = age;
this.job = job;
this.sayName = function () {
alert(this.name);
};
}
var person1 = new Person("Nicholas", 22, "software Engineer");
var person2 = new Person("Greg", 24, "student");
person1.sayName(); // Nicholas
person2.sayName(); // Greg
與工廠模式不同的是:沒有顯式建立物件、直接把屬性與方法賦給 this、沒有 return 語句。
使用 new 操作符呼叫建構函式時,實際上經歷四個步驟:
1、建立一個新物件
2、將建構函式的作用域賦給新物件(this 指向這個新物件)
3、執行建構函式中的程式碼
4、回傳新物件
此例建立的物件同時是 Object 與 Person 的實例,可用 instanceof 驗證:
alert(person1 instanceof Object); // true
但建構函式模式有個問題:sayName 方法會在每個實例上重新建立一次。以下程式碼可以證明:
alert(person1.sayName == person2.sayName); // false
解法是把方法移到建構函式外部,成為全域函式:
function Person(name, age, job) {
this.name = name;
this.age = age;
this.job = job;
}
function sayName() {
alert(this.name);
}
但這樣又產生新問題:這個全域函式實際上只能被 Person 建立的實例呼叫,名實不符;若物件需要定義很多方法,就得定義大量全域函式,完全喪失封裝性。
JavaScript 中每個函式都有一個 prototype 屬性,它是一個指向物件的指標,而該物件包含可由特定型別的所有實例共享的屬性與方法。
function Person() {}
Person.prototype.name = "Nicholas";
Person.prototype.age = 22;
Person.prototype.job = "software Engineer";
Person.prototype.sayName = function () {
alert(this.name);
};
var person1 = new Person();
var person2 = new Person();
person1.sayName(); // Nicholas
alert(person1.sayName == person2.sayName); // true
以上程式碼做了三件事:定義建構函式 Person(自動獲得 prototype 屬性,預設只含一個指向 Person 的 constructor);透過 Person.prototype 加入三個屬性與一個方法;建立實例並呼叫 sayName()。

上圖展示了 Person 建構函式、Person 的原型屬性,以及兩個實例之間的關係。Person.prototype 指向原型物件,Person.prototype.constructor 又指回 Person。原型物件除了 constructor,還包含後來加入的其他屬性與方法。兩個實例各自帶有一個內部屬性,僅指向 Person.prototype。
1、在 person1 實例上尋找 sayName(),找不到
2、沿原型鏈來到 person1 的原型,找到了,於是呼叫
基於這個查找過程,我們可以透過在實例上定義同名屬性來遮蔽原型上的屬性。注意這只是「阻擋存取」,並不會刪除原型上的屬性:
var person1 = new Person(); var person2 = new Person(); person1.name = "Greg"; alert(person1.name); // Greg —— 來自實例 alert(person2.name); // Nicholas —— 來自原型
用 delete 操作符可以完全刪除實例屬性,讓存取重新落到原型上:
delete person1.name; alert(person1.name); // Nicholas —— 來自原型
用 hasOwnProperty() 則可以判斷屬性是存在於實例還是原型:
var person1 = new Person();
var person2 = new Person();
alert(person1.hasOwnProperty("name")); // false
person1.name = "Greg";
alert(person1.name); // Greg —— 來自實例
alert(person1.hasOwnProperty("name")); // true
alert(person2.name); // Nicholas —— 來自原型
alert(person2.hasOwnProperty("name")); // false
delete person1.name;
alert(person1.name); // Nicholas —— 來自原型
alert(person1.hasOwnProperty("name")); // false

function Person() {}
Person.prototype = {
name: "Nicholas",
age: 22,
job: "software Engineer",
sayName: function () { alert(this.name); }
};
這裡 constructor 屬性不再指向 Person 了,因此無法再透過它判斷物件型別。若要修正:
Person.prototype = {
constructor: Person,
name: "Nicholas",
age: 22,
job: "software Engineer",
sayName: function () { alert(this.name); }
};
不過直接重設 constructor 會讓它的 [[Enumerable]] 特性變為 true,而原生的 constructor 預設是不可列舉的。若要更嚴謹:
Object.defineProperty(Person.prototype, "constructor", {
enumerable: false,
value: Person
});
在原型中查找值的過程是一次搜尋,因此對原型物件所做的任何修改,都能立即反映到所有實例上:
var friend = new Person();
Person.prototype.sayHi = function () {
alert("hi");
};
friend.sayHi(); // "hi" —— 沒有問題
friend 是在加入新方法之前建立的,卻仍能存取該方法,原因是實例與原型之間是一種鬆散的連結關係。
但「整體覆寫原型物件」是不同的情況:
function Person() {}
var friend = new Person();
Person.prototype = {
name: "Nicholas",
age: 22,
job: "software Engineer",
sayName: function () { alert(this.name); }
};
friend.sayName(); // 錯誤
發生錯誤是因為 friend 內部指標指向的舊原型物件並不包含 sayName,而整體指派換掉的是 Person.prototype 這個指向,並不會回頭修改舊物件。

原型省略了「為建構函式傳遞初始化參數」這一環節,所有實例預設都取得相同的值。更大的問題來自共享的本性:當原型上的屬性是參照型別時,所有實例會共用同一份資料。
function Person() {}
Person.prototype = {
constructor: Person,
name: "Nicholas",
age: 22,
job: "software Engineer",
friends: ["Shelby", "Court"],
sayName: function () { alert(this.name); }
};
var person1 = new Person();
var person2 = new Person();
person1.friends.push("Van");
alert(person1.friends); // "Shelby,Court,Van"
alert(person2.friends); // "Shelby,Court,Van" —— 被連帶影響
alert(person1.friends == person2.friends); // true —— 同一個陣列
這在實務上是災難級的 bug 來源:改動一個實例的陣列屬性,其他所有實例都跟著變。
最常見的解法:建構函式定義實例屬性,原型定義方法與共享屬性。如此每個實例都有自己的屬性複本,同時共享方法的參照,記憶體使用最有效率。
function Person(name, age, job) {
this.name = name;
this.age = age;
this.job = job;
this.friends = ["Shelby", "Court"];
}
Person.prototype = {
constructor: Person,
sayName: function () {
alert(this.name);
}
};
var person1 = new Person("Nicholas", 22, "software Engineer");
var person2 = new Person("Greg", 24, "student");
person1.friends.push("Van");
alert(person1.friends); // "Shelby,Court,Van"
alert(person2.friends); // "Shelby,Court" —— 不受影響
alert(person1.friends == person2.friends); // false
alert(person1.sayName == person2.sayName); // true —— 方法共享
這也是大多數 JavaScript 函式庫與框架內部採用的模式。
它把需要的所有資訊都封裝進建構函式中,並透過 if 判斷原型上的某個方法是否存在。若不存在(即第一次呼叫該建構函式時),才執行原型初始化程式碼。
function Person(name, age, job) {
this.name = name;
this.age = age;
this.job = job;
// 方法
if (typeof this.sayName != 'function') {
Person.prototype.sayName = function () {
alert(this.name);
};
}
}
var friend = new Person('Nicholas', '22', 'Software Engineer'); // 初次呼叫,同時完成原型初始化
var person2 = new Person('amy', '21'); // sayName 已存在,不再修改原型
這個模式兼顧了封裝性與效能,缺點是 if 判斷本身仍有微小成本,且程式碼略顯不直觀。
單一物件用字面量即可。需要建立多個同類物件時,優先考慮「建構函式 + 原型」的組合模式。若偏好更好的可讀性與語法層級的保障,ES6 的 class 語法本質上就是這個組合模式的語法糖,且自動處理了 constructor 指向、方法共享與原型污染等問題,是新專案的推薦選擇。
特別強調一個實務結論:只要屬性值是陣列或物件,就絕對不能放在原型上,必須在建構函式中初始化。這是原型模式最常見也最難查的 bug。