最近在看《JavaScript 高級程序設計》(第二版),順手把物件建立模式整理成一篇筆記。
JavaScript 雖然從技術上講是物件導向語言,但它沒有類的概念,一切都是物件。任意一個物件都是某種引用類型的實例,而引用類型可以是原生的(Object、Array、Date、RegExp、Function),也可以是自訂的。引用類型本質上是一種把資料與功能組織在一起的資料結構。既然缺乏類的概念,如何高效建立物件就成了必須解決的問題。
var person = {}; //物件字面量表示,等同於 var person = new Object();
person.name = 'evansdiy';
person.age = '22';
person.friends = ['ajiao', 'tiantian', 'pangzi'];
person.logName = function() { console.log(this.name); }
這樣建立了包含四個屬性的物件,其中一個是方法。如果需要很多類似 person 的實例,就會有許多重複程式碼。
透過一個包含物件細節的函式來建立物件,然後把它回傳。
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 建立新物件並回傳,除此之外 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');
person1.logName(); //boy-a
person2.logName(); //girl-b
對比工廠模式,這裡不需要建立中間物件,也沒有 return。更重要的是,可以把構造函式的實例標識為一種特定的類型,這解決了物件識別問題:
console.log(person1.constructor == Person); //true,constructor 位於原型中並指向構造函式 console.log(person1 instanceof Person); //true
但構造函式模式也有問題:logName 方法在每個實例上都會被重新建立一次,因此:
console.log(person1.logName == person2.logName); //false
解法是把方法移到構造器外部變成全域函式:
function logName() { console.log(this.name); }
function logAge() { console.log(this.age); }
但全域函式實際上只能被經由 Person 建立的實例呼叫,名實不符;方法一多還要逐一定義,缺少封裝性。
JavaScript 中每個函式都包含一個指向 prototype 屬性的指針(多數瀏覽器可透過 __proto__ 存取),prototype 是一個物件,其中包含由該引用類型建立的所有實例共享的屬性與方法。
function Person() { }
Person.name = 'evansdiy';
Person.prototype.friends = ['ajiao', 'jianjian', 'pangzi'];
Person.prototype.logName = function() { console.log(this.name); }
var person1 = new Person();
person1.logName(); //'evansdiy'
logName() 的呼叫過程是:先在 person1 實例上查找,找不到於是回溯到原型;在原型上找到後呼叫。
基於這個查找過程,我們可以透過在實例上定義原型中的同名屬性來阻止該實例存取原型上的同名屬性(注意這並不會刪除原型上的屬性,只是遮蔽):
var person2 = new Person(); person2.name = 'laocai'; delete person2.name; //不再需要時用 delete 移除
用 for-in 可以列舉實例能存取到的所有屬性(不論存在於實例或原型);用 hasOwnProperty() 則能判斷屬性究竟在哪一邊,只有存在於實例中才回傳 true:
for (i in person1) { console.log(i); }
console.log(person1.hasOwnProperty('name')); //true
//判斷屬性是否存在於原型中
console.log(('friends' in person1) && !person1.hasOwnProperty('friends'));
hasOwnProperty 來自 Object 的原型,是 JavaScript 中唯一一個處理屬性時不查找原型鏈的方法。
原型也可以用物件字面量語法來寫:
Person.prototype = {
name: 'evansdiy',
friends: ['ajiao', 'jianjian', 'pangzi'],
logName: function() { console.log(this.name); }
}
但要注意,物件字面量語法重寫整個 prototype 後,原先默認取得的 constructor 屬性會指向 Object 構造函式:
console.log(person1.constructor); //Object console.log(person1 instanceof Person); //仍然是 true
解法是手動把 constructor 設回來:
Person.prototype = {
constructor: Person,
......
}
還有一個重要特性:在建立實例之後修改原型,改動會立即反映在所有實例上,因為實例與原型之間的連接只是一個指針,而非複本。
function Person() { };
var person1 = new Person();
Person.prototype.name = 'evansdiy';
console.log(person1.name); //'evansdiy'
但如果是重寫原型,情況就不同了:
function Person() { };
var person1 = new Person(); //這個實例參照的是最初的原型
Person.prototype = { friends: ['ajiao', 'jianjian', 'pangzi'] }
var person2 = new Person(); //這個實例參照新的原型
console.log(person2.friends); //有值
console.log(person1.friends); //undefined
重寫原型切斷了現有原型與先前建立的所有實例之間的聯繫,先前實例的原型還在,只是變成了舊的。此時 person1.constructor 仍是 Person(),而 person2.constructor 已指向 Object()。
原型模式有兩個明顯問題:一是忽略了為構造函式傳遞初始化參數,所有實例都取得相同的屬性值;二是原型中的引用類型值會被所有實例共享:
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,各自的 friends 互不干擾
把需要的所有資訊都封裝到構造函式中,透過 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'); //方法已存在,不再修改原型
關鍵眉角:這個模式不能使用物件字面量語法書寫原型,因為那會重寫整個原型物件。若真的重寫,透過構造函式建立的第一個實例將存取不到 if 區塊中的屬性:
function Person(name, age) {
this.name = name;
this.age = age;
if (typeof this.logName != 'function') {
Person.prototype = { //不建議這樣寫
logName: function() { console.log(this.name); },
logAge: function() { console.log(this.Age); }
}
};
}
var person1 = new Person('evansdiy', '22');
var person2 = new Person('amy', '21');
person2.logName(); //'amy'
person1.logName(); //logName() 方法不存在
各模式都有自己的適用場景,無所謂絕對優劣。理解每個模式的取捨,才能在實戰中選對工具。