DIV CSS 佈局教程網

JavaScript 建立物件的多種模式全解:從字面量到動態原型
編輯:關於JavaScript     

JavaScript 雖然是一門物件導向語言,卻沒有 class 的概念——一切都是物件,而每個物件都是某個參照類型的實例。如何在這套規則下優雅地建立物件,就衍生出多種模式。

六種主要模式

物件字面量、工廠模式、建構函式模式、原型模式、建構函式與原型組合、動態原型模式。以下逐一剖析,並說明各自的問題所在。

一、物件字面量

var person = {
    name: 'Nicholas',
    age: '22',
    job: "software Engineer",
    sayName: function () {
        alert(this.name);
    }
};

建立了一個名為 person 的物件,加上三個屬性與一個方法,其中 sayName() 用於顯示 this.name 的值。

明顯缺點:用同一個介面建立大量物件時,會產生大量重複程式碼。

二、工廠模式

工廠模式是軟體工程領域廣為人知的設計模式,它用函式封裝了「建立具體物件」的細節。

function createPerson(name, age, job) {
    var o = new Object();
    o.name = name;
    o.age = age;
    o.job = job;
    o.sayName = function () {
        alert(this.name);
    };
    return o;
}

var person1 = createPerson("Nicholas", 22, "software Engineer");
var person2 = createPerson("Greg", 24, "student");

createPerson 函式能依傳入參數建構出包含所有必要資訊的物件,可以無限次呼叫,每次都回傳一個含三個屬性與一個方法的新物件。

工廠模式解決了「建立多個相似物件」的問題,卻沒有解決物件識別的問題——也就是說,我們無從得知一個物件的型別。

三、建構函式模式

function Person(name, age, job) {
    this.name = name;
    this.age = age;
    this.job = job;
    this.sayName = function () {
        alert(this.name);
    };
}

var person1 = new Person("Nicholas", 22, "software Engineer");
var person2 = new Person("Greg", 24, "student");
person1.sayName(); // Nicholas
person2.sayName(); // Greg

與工廠模式不同的是:沒有顯式建立物件、直接把屬性與方法賦給 this、沒有 return 語句。

使用 new 操作符呼叫建構函式時,實際上經歷四個步驟:

1、建立一個新物件
2、將建構函式的作用域賦給新物件(this 指向這個新物件)
3、執行建構函式中的程式碼
4、回傳新物件

此例建立的物件同時是 Object 與 Person 的實例,可用 instanceof 驗證:

alert(person1 instanceof Object); // true

但建構函式模式有個問題:sayName 方法會在每個實例上重新建立一次。以下程式碼可以證明:

alert(person1.sayName == person2.sayName); // false

解法是把方法移到建構函式外部,成為全域函式:

function Person(name, age, job) {
    this.name = name;
    this.age = age;
    this.job = job;
}
function sayName() {
    alert(this.name);
}

但這樣又產生新問題:這個全域函式實際上只能被 Person 建立的實例呼叫,名實不符;若物件需要定義很多方法,就得定義大量全域函式,完全喪失封裝性。

四、原型模式

JavaScript 中每個函式都有一個 prototype 屬性,它是一個指向物件的指標,而該物件包含可由特定型別的所有實例共享的屬性與方法。

function Person() {}

Person.prototype.name = "Nicholas";
Person.prototype.age = 22;
Person.prototype.job = "software Engineer";
Person.prototype.sayName = function () {
    alert(this.name);
};

var person1 = new Person();
var person2 = new Person();
person1.sayName();                              // Nicholas
alert(person1.sayName == person2.sayName);      // true

以上程式碼做了三件事:定義建構函式 Person(自動獲得 prototype 屬性,預設只含一個指向 Person 的 constructor);透過 Person.prototype 加入三個屬性與一個方法;建立實例並呼叫 sayName()。

上圖展示了 Person 建構函式、Person 的原型屬性,以及兩個實例之間的關係。Person.prototype 指向原型物件,Person.prototype.constructor 又指回 Person。原型物件除了 constructor,還包含後來加入的其他屬性與方法。兩個實例各自帶有一個內部屬性,僅指向 Person.prototype。

sayName() 的呼叫過程

1、在 person1 實例上尋找 sayName(),找不到
2、沿原型鏈來到 person1 的原型,找到了,於是呼叫

基於這個查找過程,我們可以透過在實例上定義同名屬性來遮蔽原型上的屬性。注意這只是「阻擋存取」,並不會刪除原型上的屬性:

var person1 = new Person();
var person2 = new Person();

person1.name = "Greg";
alert(person1.name); // Greg —— 來自實例
alert(person2.name); // Nicholas —— 來自原型

用 delete 操作符可以完全刪除實例屬性,讓存取重新落到原型上:

delete person1.name;
alert(person1.name); // Nicholas —— 來自原型

用 hasOwnProperty() 則可以判斷屬性是存在於實例還是原型:

var person1 = new Person();
var person2 = new Person();

alert(person1.hasOwnProperty("name")); // false
person1.name = "Greg";
alert(person1.name);                   // Greg —— 來自實例
alert(person1.hasOwnProperty("name")); // true
alert(person2.name);                   // Nicholas —— 來自原型
alert(person2.hasOwnProperty("name")); // false

delete person1.name;
alert(person1.name);                   // Nicholas —— 來自原型
alert(person1.hasOwnProperty("name")); // false

較簡潔的原型語法,以及它的代價

function Person() {}
Person.prototype = {
    name: "Nicholas",
    age: 22,
    job: "software Engineer",
    sayName: function () { alert(this.name); }
};

這裡 constructor 屬性不再指向 Person 了,因此無法再透過它判斷物件型別。若要修正:

Person.prototype = {
    constructor: Person,
    name: "Nicholas",
    age: 22,
    job: "software Engineer",
    sayName: function () { alert(this.name); }
};

不過直接重設 constructor 會讓它的 [[Enumerable]] 特性變為 true,而原生的 constructor 預設是不可列舉的。若要更嚴謹:

Object.defineProperty(Person.prototype, "constructor", {
    enumerable: false,
    value: Person
});

原型的動態性

在原型中查找值的過程是一次搜尋,因此對原型物件所做的任何修改,都能立即反映到所有實例上:

var friend = new Person();

Person.prototype.sayHi = function () {
    alert("hi");
};
friend.sayHi(); // "hi" —— 沒有問題

friend 是在加入新方法之前建立的,卻仍能存取該方法,原因是實例與原型之間是一種鬆散的連結關係。

但「整體覆寫原型物件」是不同的情況:

function Person() {}
var friend = new Person();

Person.prototype = {
    name: "Nicholas",
    age: 22,
    job: "software Engineer",
    sayName: function () { alert(this.name); }
};

friend.sayName(); // 錯誤

發生錯誤是因為 friend 內部指標指向的舊原型物件並不包含 sayName,而整體指派換掉的是 Person.prototype 這個指向,並不會回頭修改舊物件。

原型模式的致命問題

原型省略了「為建構函式傳遞初始化參數」這一環節,所有實例預設都取得相同的值。更大的問題來自共享的本性:當原型上的屬性是參照型別時,所有實例會共用同一份資料。

function Person() {}
Person.prototype = {
    constructor: Person,
    name: "Nicholas",
    age: 22,
    job: "software Engineer",
    friends: ["Shelby", "Court"],
    sayName: function () { alert(this.name); }
};

var person1 = new Person();
var person2 = new Person();

person1.friends.push("Van");
alert(person1.friends);               // "Shelby,Court,Van"
alert(person2.friends);               // "Shelby,Court,Van" —— 被連帶影響
alert(person1.friends == person2.friends); // true —— 同一個陣列

這在實務上是災難級的 bug 來源:改動一個實例的陣列屬性,其他所有實例都跟著變。

五、組合使用建構函式模式與原型模式

最常見的解法:建構函式定義實例屬性,原型定義方法與共享屬性。如此每個實例都有自己的屬性複本,同時共享方法的參照,記憶體使用最有效率。

function Person(name, age, job) {
    this.name = name;
    this.age = age;
    this.job = job;
    this.friends = ["Shelby", "Court"];
}

Person.prototype = {
    constructor: Person,
    sayName: function () {
        alert(this.name);
    }
};

var person1 = new Person("Nicholas", 22, "software Engineer");
var person2 = new Person("Greg", 24, "student");

person1.friends.push("Van");
alert(person1.friends);                    // "Shelby,Court,Van"
alert(person2.friends);                    // "Shelby,Court" —— 不受影響
alert(person1.friends == person2.friends); // false
alert(person1.sayName == person2.sayName); // true —— 方法共享

這也是大多數 JavaScript 函式庫與框架內部採用的模式。

六、動態原型模式

它把需要的所有資訊都封裝進建構函式中,並透過 if 判斷原型上的某個方法是否存在。若不存在(即第一次呼叫該建構函式時),才執行原型初始化程式碼。

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);
        };
    }
}

var friend = new Person('Nicholas', '22', 'Software Engineer'); // 初次呼叫,同時完成原型初始化
var person2 = new Person('amy', '21');                          // sayName 已存在,不再修改原型

這個模式兼顧了封裝性與效能,缺點是 if 判斷本身仍有微小成本,且程式碼略顯不直觀。

模式選擇建議

單一物件用字面量即可。需要建立多個同類物件時,優先考慮「建構函式 + 原型」的組合模式。若偏好更好的可讀性與語法層級的保障,ES6 的 class 語法本質上就是這個組合模式的語法糖,且自動處理了 constructor 指向、方法共享與原型污染等問題,是新專案的推薦選擇。

特別強調一個實務結論:只要屬性值是陣列或物件,就絕對不能放在原型上,必須在建構函式中初始化。這是原型模式最常見也最難查的 bug。

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