用建構函數或對象字面值創建對象時,若要產生大量結構相同的實例,程式碼會迅速膨脹。JavaScript 社群因此發展出多種創建模式,各有其要解決的問題。本文依時序梳理這條演化路線。
var p1 = {
name: "xxyh", age: 19, job: "programmer",
sayHello: function () { alert(this.name); }
};
var p2 = {
name: "zhangsan", age: 18, job: "student",
sayHello: function () { alert(this.name); }
};
每新增一個人就要重抄一次方法定義,顯然不可行。
function createPerson(name, age, job) {
var obj = new Object();
obj.name = name;
obj.age = age;
obj.job = job;
obj.sayHello = function () { alert(this.name); };
return obj;
}
var p1 = createPerson("xxyh", 19, "programmer");
var p2 = createPerson("zhangsan", 18, "student");
程式碼大幅精簡了,但存在一個關鍵缺陷:無法確定對象的類型。p1 看起來只是個普通 Object,沒有任何標記能告訴你它是「Person」。
function Person(name, age, job) {
this.name = name;
this.age = age;
this.job = job;
this.sayName = function () { alert(this.name); };
}
var p1 = new Person("xxyh", 19, "programmer");
var p2 = new Person("Jack", 18, "student");
與工廠模式相比有三點不同:沒有顯式創建對象、直接把屬性方法賦給 this、沒有 return。
使用 new 時,引擎實際做了四件事:
this 指向它)。類型資訊因此被保留下來:
alert(p1.constructor == Person); // true
alert(p2.constructor == Person); // true
實務上檢測類型更推薦 instanceof:
alert(p1 instanceof Object); // true
alert(p1 instanceof Person); // true
alert(p2 instanceof Object); // true
alert(p2 instanceof Person); // true
兩者都為 true,因為所有對象都繼承自 Object。
// 作為構造函數
var person = new Person("xxyh", 19, "programmer");
person.sayName(); // "xxyh"
// 作為普通函數:this 指向全域
Person("zhangsan", 18, "student");
window.sayName(); // "zhangsan"
// 用 call 指定作用域
var obj = new Object();
Person.call(obj, "Jack", 29, "manager");
obj.sayName(); // "Jack"
每個實例都要重新建立一遍方法。p1 與 p2 各自有一個 sayName,但它們不是同一個 Function 實例。JavaScript 中函數即對象,每定義一次就實例化一個對象:
alert(p1.sayName == p2.sayName); // false
把方法移到外部雖然能讓兩者共享,但代價是污染全域作用域,且方法一多就完全失去封裝:
function Person(name, age, job) {
this.name = name;
this.age = age;
this.job = job;
this.sayName = sayName; // 指向全域函數
}
function sayName() { alert(this.name); }
每個函數都有一個 prototype 屬性,指向一個對象。這個對象的用途是存放可被子類型所有實例共享的屬性與方法。
function Person() { }
Person.prototype.name = "xxyh";
Person.prototype.age = 19;
Person.prototype.job = "programmer";
Person.prototype.sayName = function () { alert(this.name); };
var person1 = new Person();
person1.sayName(); // "xxyh"
var person2 = new Person();
person2.sayName(); // "xxyh"
alert(person1.sayName == person2.sayName); // true,共享同一個函數
建立函數時會自動產生 prototype,而原型對象默認會獲得一個 constructor 屬性指回該函數,即 Person.prototype.constructor === Person。
呼叫構造函數創建實例時,實例內部會有一個指向原型對象的指針([[Prototype]],Firefox/Safari/Chrome 可以 __proto__ 存取)。這個連結存在於實例與構造函數的原型之間,而非實例與構造函數之間。

無法直接讀取 [[Prototype]],但可以用 isPrototypeOf() 檢測關係:
alert(Person.prototype.isPrototypeOf(person1)); // true
alert(Person.prototype.isPrototypeOf(person2)); // true
讀取屬性時會執行一次搜索,順序是:先在實例本身找,找到就回傳;沒找到則沿指針到原型對象找。
可以讀取原型中的值,但無法透過實例改寫原型中的值。在實例上設定同名屬性只會建立一個實例屬性,把原型屬性遮蔽掉:
Person.prototype.name = "xxyh";
var person1 = new Person();
var person2 = new Person();
person1.name = "oooo";
alert(person1.name); // "oooo" ← 實例屬性遮蔽了原型
alert(person2.name); // "xxyh" ← 原型不受影響
用 delete 移除實例屬性後,原型屬性會重新露出來:
delete person1.name;
alert(person1.name); // "xxyh"
hasOwnProperty() 可以判斷屬性在哪一層:
alert(person1.hasOwnProperty("name")); // false,還在原型上
person1.name = "oooo";
alert(person1.hasOwnProperty("name")); // true,已成為實例屬性

單獨使用 in 時,只要對象能訪問到該屬性就回傳 true,不論它在實例還是原型上:
alert("name" in person1); // true
person1.name = "oooo";
alert("name" in person1); // true
搭配 hasOwnProperty 就能分辨:in 為 true 而 hasOwnProperty 為 false,即原型屬性。
function hasPrototypeProperty(object, name) {
return !object.hasOwnProperty(name) && (name in object);
}
var person = new Person();
alert(hasPrototypeProperty(person, "name")); // true
person.name = "oooo";
alert(hasPrototypeProperty(person, "name")); // false
for...in 會回傳所有能訪問到的可枚舉屬性,包含實例與原型。要只取實例的可枚舉屬性,用 Object.keys():
var keys = Object.keys(Person.prototype);
alert(keys); // name, age, job, sayName
var p1 = new Person();
p1.name = "oooo";
p1.age = 15;
alert(Object.keys(p1)); // name, age
要取得包含不可枚舉屬性的全部自有屬性,用 Object.getOwnPropertyNames():
alert(Object.getOwnPropertyNames(Person.prototype));
// "constructor,name,age,job,sayName"
function Person() { }
Person.prototype = {
name: "xxyh",
age: 18,
job: "programmer",
sayName: function () { alert(this.name); }
};
結果相同,但有一個副作用:constructor 屬性不再指向 Person,因為整個原型對象被換成一個新的字面值對象,其 constructor 自然指向 Object。
var boy = new Person();
alert(boy instanceof Object); // true
alert(boy instanceof Person); // true
alert(boy.constructor == Person); // false
alert(boy.constructor == Object); // true
修正方式是在字面值中顯式補回:
Person.prototype = {
constructor: Person,
name: "xxyh",
age: 18,
job: "programmer",
sayName: function () { alert(this.name); }
};
這個屬性通常不可枚舉,若在意可改用 Object.defineProperty 設定 enumerable: false。
由於查找是一次實時搜索,對原型所做的任何修改都會立即反映到所有實例上。但整體替換原型對象則不同:實例的指針仍指向最初那個原型,替換等於切斷了它們與新原型之間的連結。
function Person() { }
var boy = new Person(); // 此時 boy 指向「最初的原型」
Person.prototype = { // 換成新對象
constructor: Person,
name: "xxyh",
sayName: function () { alert(this.name); }
};
boy.sayName(); // TypeError:sayName 不在 boy 所指向的舊原型上

結論:實例中的指針只指向原型,不指向構造函數。所以替換原型之前已建立的實例,永遠看不到新的原型。
所有原生引用類型的方法都定義在各自構造函數的原型上,因此你也可以擴充:
String.prototype.startsWith = function (text) {
return this.indexOf(text) === 0;
};
var msg = "good morning";
alert(msg.startsWith("good")); // true
(ES6 已內建 startsWith,此處僅作示範。)修改內建原型是爭議性做法:容易與其他庫衝突,也可能讓 for...in 出現意料外的屬性。除非是實作 polyfill,否則不建議這麼做。
一是所有實例默認取得相同的值;二是原型上的屬性由所有實例共享。第二點對函數是優點,對可變資料則是災難:
Person.prototype = {
constructor: Person,
name: "xxyh",
friends: ["張三", "李四"],
sayName: function () { alert(this.name); }
};
var p1 = new Person();
var p2 = new Person();
p1.friends.push("王五");
alert(p1.friends); // 張三,李四,王五
alert(p2.friends); // 張三,李四,王五 ← 被連帶修改
alert(p1.friends === p2.friends); // true,同一個陣列
最常見的解法:構造函數負責實例屬性,原型負責方法與共享屬性。
function Person(name, age, job) {
this.name = name;
this.age = age;
this.job = job;
this.friends = ["張三", "李四"];
}
Person.prototype = {
constructor: Person,
sayName: function () { alert(this.name); }
};
var p1 = new Person("蕭蕭弈寒", 18, "programmer");
var p2 = new Person("魁拔", 10, "捉妖");
p1.friends.push("王五");
alert(p1.friends); // 張三,李四,王五
alert(p2.friends); // 張三,李四
alert(p1.friends === p2.friends); // false,各自獨立
alert(p1.sayName === p2.sayName); // true,共享方法
這也是目前最廣泛使用的模式。
把所有資訊封裝回構造函數內部,並在構造時檢查某個方法是否存在來決定是否初始化原型:
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); };
}
}
因為原型初始化只在第一次呼叫時發生,後續呼叫不再進入那個 if,所以幾乎沒有額外開銷。它同時保有兩種模式的優點,是很值得採用的折衷。
建立一個函數包住創建過程,最後回傳新對象:
function Person(name, age) {
var obj = new Object();
obj.name = name;
obj.age = age;
obj.sayName = function () { alert(this.name); };
return obj;
}
var boy = new Person("xxyh", 19);
boy.sayName();
要注意的是,回傳的對象與構造函數及其原型沒有任何關聯,因此無法用 instanceof 判定類型。它的存在意義是在需要「返回非 this 對象」的特殊情境下(例如要回傳陣列或自訂展開的物件)提供一個寫法。
穩妥對象指沒有公共屬性、方法也不引用 this 的對象。它與寄生模式類似,但有兩點差異:方法不引用 this,且不需用 new 調用。
function Person(name, age, job) {
var obj = new Object();
// 方法直接閉包 name,不透過 this
obj.sayName = function () { alert(name); };
return obj;
}
// 直接呼叫,不加 new
var person = Person("xxyh", 19, "programmer");
person.sayName(); // "xxyh"
適用於對安全性有疑慮的環境(例如沙箱),因為即使對象被丟進不可信的程式碼中,也不會透過 this 洩漏或讓外部改動內部狀態。缺點是每個實例的方法無法共享,記憶體開銷較大。
class,語法糖背後就是原型,但可讀性與繼承寫法都更好。instanceof 失效的代價。