重讀《JavaScript 高級程序設計》時,把「建立物件」這一章的幾種模式整理成一篇筆記。JavaScript 沒有 class(至少在 ES5 時代沒有),一切都是物件,因此「如何有效率地批量建立物件」就成了必修題。
var person = {}; // 等同 var person = new Object();
person.name = 'evansdiy';
person.age = '22';
person.friends = ['ajiao', 'tiantian', 'pangzi'];
person.logName = function () { console.log(this.name); };
問題很明顯:想建立十個類似物件,就得重複十次一樣的程式碼。
function person(name, age, friends) {
var o = {
name: name, age: age, friends: friends,
logName: function () { console.log(this.name); }
};
return o;
}
var person1 = person('Evansdiy', '22', ['ajiao', 'tiantian', 'pangzi']);
封裝了細節,但缺點有兩個:那個中間物件 o 除了被回傳之外毫無用途;更重要的是——你無法判斷這個物件的「型別」是什麼。
function Person(name, age, job) {
this.name = name;
this.age = age;
this.job = job;
this.logName = function () { console.log(this.name); };
}
var person1 = new Person('boy-a', '22', 'worker');
var person2 = new Person('girl-b', '23', 'teacher');
console.log(person1.constructor == Person); // true
console.log(person1 instanceof Person); // true
console.log(person1.logName == person2.logName); // false ← 問題所在
用 new 之後不需要中間物件、也不用 return,而且能透過 constructor 或 instanceof 辨識型別,物件識別的問題解決了。但每個實例都會各自產生一份 logName 函式。
把方法搬到外面當全域函式確實能共用,但那些函式實際上只服務於 Person,放在全域顯得名不副實,方法一多更是混亂,封裝性蕩然無存。
每個函式都有一個 prototype 屬性,它是一個物件,用來存放所有實例共享的屬性與方法。
function Person() {}
Person.prototype.name = 'evansdiy';
Person.prototype.friends = ['ajiao', 'jianjian', 'pangzi'];
Person.prototype.logName = function () { console.log(this.name); };
var person1 = new Person();
person1.logName(); // 'evansdiy'
這裡發生了三件事:定義構造函式(自動獲得只含 constructor 的 prototype);往 prototype 掛上三個成員;建立實例並呼叫方法。
logName() 的查找過程是:先在 person1 自身找 → 找不到 → 沿原型鏈找到 prototype 上的方法 → 執行。因此若在實例上定義同名屬性,只是「遮斷」了對原型的存取,並不會刪除原型上的屬性;用 delete 就能撤銷遮蔽。
var person2 = new Person();
person2.name = 'laocai'; // 遮蔽原型上的 name
delete person2.name; // 撤銷遮蔽
console.log(person1.hasOwnProperty('name')); // false,在原型上
console.log(('friends' in person1) && !person1.hasOwnProperty('friends')); // true
hasOwnProperty() 是唯一判斷屬性時不走原型鏈的方法,搭配 in 就能分辨屬性到底住在實例還是原型。
原型也可以寫成字面量,但這會整體覆寫 prototype,導致 constructor 指回 Object:
Person.prototype = {
constructor: Person, // 需要時手動補回
name: 'evansdiy',
friends: ['ajiao', 'jianjian', 'pangzi'],
logName: function () { console.log(this.name); }
};
原型的動態性值得注意:實例與原型之間只是一個指標,不是拷貝。所以建立實例之後才新增的屬性,該實例也讀得到:
function Person() {}
var person1 = new Person();
Person.prototype.name = 'evansdiy';
console.log(person1.name); // 'evansdiy'
但如果是整體重寫 prototype,情況就完全不同——舊實例仍指向舊原型,新實例指向新原型,兩邊的 constructor 也會不一致。重寫原型等於切斷了與既有實例的連結。
原型模式還有兩個致命傷:無法在建立時傳入初始化參數;原型上的引用型別會被所有實例共享。
function Person() {}
Person.prototype = { friends: ['ajiao', 'tiantian', 'pangzi'] };
var person1 = new Person();
var person2 = new Person();
person1.friends.push('laocai');
console.log(person2.friends); // ['ajiao','tiantian','pangzi','laocai'] ← 被連帶修改
原因在於原型上的 friends 只是一個指向堆記憶體的指標,實例是「按指標存取」,並不存在各自的副本。
用構造函數處理「每個實例各自擁有」的屬性,用原型處理「大家共用」的方法,互補彼此的短板,這也是實務上最常見的寫法。
function Person(name, age) {
this.name = name;
this.age = age;
this.friends = ['ajiao', 'jianjian', 'pangzi']; // 各自獨立
}
Person.prototype = {
constructor: Person,
logName: function () { console.log(this.name); } // 共享
};
var person1 = new Person('evansdiy', '22');
var person2 = new Person('amy', '21');
person1.logName(); // 'evansdiy'
person1.friends.push('haixao');
console.log(person2.friends.length); // 3,不受影響
把資訊全部收進構造函式,用 if 判斷某方法是否存在,只在第一次呼叫時初始化原型:
function Person(name, age) {
this.name = name;
this.age = age;
if (typeof this.logName != 'function') {
Person.prototype.logName = function () { console.log(this.name); };
Person.prototype.logAge = function () { console.log(this.age); };
}
}
var person1 = new Person('evansdiy', '22'); // 首次呼叫,初始化原型
var person2 = new Person('amy', '21'); // 已存在,不再處理
要注意:這裡不能用字面量整體覆寫 prototype,否則第一個實例將拿不到 if 中的那些方法。
每種模式都有適用場景,談不上絕對優劣。組合模式最通用,動態原型模式在語法上最乾淨,理解原型鏈則是讀懂所有模式的前提。