前言
JavaScript 建立物件的方式很多,這裡整理四種常見模式並列出各自的優缺點,方便依場景挑選。
工廠模式
function createPerson(name, age) {
var obj = new Object();
obj.name = name;
obj.age = age;
return obj; // 一定要回傳,否則會得到 undefined
}
var person1 = new createPerson('Young', 18);
console.log(person1.name + ':' + person1.age);
優點:可以批次建立多個相似物件。
缺點:沒有解決物件識別問題,也就是無法判斷某個物件屬於哪一種類型。
構造函式模式
function Person(name, age) {
this.name = name;
this.age = age;
}
var person1 = new Person('Young', 18);
console.log(person1.name + ':' + person1.age);
先說說它有趣的地方——構造函式其實就是普通函式,只是可以用 new 呼叫:
function Person(name, age) {
this.name = name;
this.age = age;
this.sayName = function () { return this.name; }
}
var person1 = new Person('Young', 18); // 當構造函式用
person1.sayName();
Person('Wind', 18); // 當普通函式呼叫
console.log(window.sayName());
var obj = new Object();
Person.call(obj, 'bird', 100); // 在另一個作用域中呼叫
console.log(obj.sayName());
優點:實例可以被標識為特定類型(person1 instanceof Person 為 true)。
缺點:每個方法都要在每個實例上重新建立一次。可以改成呼叫全域函式:
function Person(name, age) {
this.name = name;
this.age = age;
this.sayName = sayName;
}
function sayName() { return this.name; }
但這樣一來就毫無封裝性可言了。原型模式正好能補上這個缺口。
原型模式
function Person() { }
Person.prototype.name = 'Young';
Person.prototype.age = 18;
Person.prototype.sayName = function () { return this.name; }
var person1 = new Person();
console.log(person1.sayName());
var person2 = new Person();
alert(person1.sayName === person2.sayName); // true,兩者共用同一個函式
雖然能透過實例讀取原型上的值,但實例無法改寫原型中的值:
function Person() { }
Person.prototype.name = 'Young';
Person.prototype.sayName = function () { return this.name; }
var person1 = new Person();
var person2 = new Person();
person1.name = 'Wind';
console.log(person1.sayName()); // Wind
console.log(person2.sayName()); // Young
呼叫 person1.sayName 時,解析器會先在實例上找屬性,找不到才往原型走。所以上面 person1 改的是自己的 name,不影響原型。
function Person() { }
Person.prototype.name = 'Young';
Person.prototype.sayName = function () { return this.name; }
var person1 = new Person();
var person2 = new Person();
person1.name = 'Wind';
console.log(person1.sayName()); // Wind
delete person1.name;
console.log(person1.sayName()); // Young,刪掉實例屬性後又回到原型
用 hasOwnProperty 可以判斷屬性是位於實例還是原型(實例為 true,原型為 false);用 Object.keys() 則能列出物件自身的可枚舉屬性:
function Person() { }
Person.prototype.name = 'Young';
Person.prototype.age = 18;
Person.prototype.sayName = function () { return this.name; }
var keys = Object.keys(Person.prototype);
console.log(keys); // ["name", "age", "sayName"]
優點:方法不必每個實例重申一遍。
缺點:很少有人單獨使用,問題出在資料也放在原型上:
function Person() { }
Person.prototype = {
constructor: Person,
name: 'Young',
age: 18,
friends: ['Big', 'Pig'],
sayName: function () { return this.name; }
};
var p1 = new Person();
var p2 = new Person();
p1.friends.push('Mon');
console.log(p1.friends); // ["Big", "Pig", "Mon"]
console.log(p2.friends); // ["Big", "Pig", "Mon"] —— 被連帶修改了
因為陣列是參考型別,所有實例共用同一份,改一個等於改全部。
組合使用構造函式與原型
function Person(name, age) {
this.name = name;
this.age = age;
this.friends = ['Big', 'Pig']; // 每個實例各自一份
}
Person.prototype = {
sayName: function () { return this.name; } // 方法共用
};
var p1 = new Person('Young', 18);
var p2 = new Person('Wind', 78);
p1.friends.push('Raganya');
console.log(p1.friends); // ["Big", "Pig", "Raganya"]
console.log(p2.friends); // ["Big", "Pig"]
console.log(p1.friends == p2.friends); // false
console.log(p1.sayName == p2.sayName); // true
把「每個物件各自的資料」放進構造函式,把「所有物件共用的行為」掛到原型上,兩者的缺點正好互相抵銷。這也是目前最廣泛使用、認同度最高的建立自訂類型方式,可視為定義參考類型的預設模式。
總結
四種模式各有適用範圍:工廠適合快速量產但不在意型別識別;純構造函式簡單卻有資源浪費;純原型有共用資料的陷阱;組合模式則是實務上的最佳平衡點。理解了原型鏈的查找順序,這四者的取捨其實很自然。