DIV CSS 佈局教程網

深入淺出:JavaScript 建立物件的多種模式比較
編輯:關於JavaScript     

重讀《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); };

問題很明顯:想建立十個類似物件,就得重複十次一樣的程式碼。

1. 工廠模式

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 除了被回傳之外毫無用途;更重要的是——你無法判斷這個物件的「型別」是什麼。

2. 構造函數模式

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,放在全域顯得名不副實,方法一多更是混亂,封裝性蕩然無存。

3. 原型模式

每個函式都有一個 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 只是一個指向堆記憶體的指標,實例是「按指標存取」,並不存在各自的副本。

4. 組合模式(構造函數 + 原型)

用構造函數處理「每個實例各自擁有」的屬性,用原型處理「大家共用」的方法,互補彼此的短板,這也是實務上最常見的寫法。

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,不受影響

5. 動態原型模式

把資訊全部收進構造函式,用 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 中的那些方法。

結語

每種模式都有適用場景,談不上絕對優劣。組合模式最通用,動態原型模式在語法上最乾淨,理解原型鏈則是讀懂所有模式的前提。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved