DIV CSS 佈局教程網

JavaScript 對象創建方式全解:從工廠模式到原型鏈
編輯:關於JavaScript     

用建構函數或對象字面值創建對象時,若要產生大量結構相同的實例,程式碼會迅速膨脹。JavaScript 社群因此發展出多種創建模式,各有其要解決的問題。本文依時序梳理這條演化路線。

起點:重複的痛

var p1 = {
  name: "xxyh", age: 19, job: "programmer",
  sayHello: function () { alert(this.name); }
};
var p2 = {
  name: "zhangsan", age: 18, job: "student",
  sayHello: function () { alert(this.name); }
};

每新增一個人就要重抄一次方法定義,顯然不可行。

工廠模式

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

var p1 = createPerson("xxyh", 19, "programmer");
var p2 = createPerson("zhangsan", 18, "student");

程式碼大幅精簡了,但存在一個關鍵缺陷:無法確定對象的類型。p1 看起來只是個普通 Object,沒有任何標記能告訴你它是「Person」。

構造函數模式

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

var p1 = new Person("xxyh", 19, "programmer");
var p2 = new Person("Jack", 18, "student");

與工廠模式相比有三點不同:沒有顯式創建對象、直接把屬性方法賦給 this、沒有 return。

使用 new 時,引擎實際做了四件事:

  1. 建立一個新對象。
  2. 把構造函數的作用域賦給這個新對象(即 this 指向它)。
  3. 執行構造函數中的程式碼。
  4. 回傳這個新對象。

類型資訊因此被保留下來:

alert(p1.constructor == Person); // true
alert(p2.constructor == Person); // true

實務上檢測類型更推薦 instanceof:

alert(p1 instanceof Object); // true
alert(p1 instanceof Person); // true
alert(p2 instanceof Object); // true
alert(p2 instanceof Person); // true

兩者都為 true,因為所有對象都繼承自 Object。

構造函數當普通函數調用

// 作為構造函數
var person = new Person("xxyh", 19, "programmer");
person.sayName();          // "xxyh"

// 作為普通函數:this 指向全域
Person("zhangsan", 18, "student");
window.sayName();          // "zhangsan"

// 用 call 指定作用域
var obj = new Object();
Person.call(obj, "Jack", 29, "manager");
obj.sayName();             // "Jack"

構造函數的問題

每個實例都要重新建立一遍方法。p1 與 p2 各自有一個 sayName,但它們不是同一個 Function 實例。JavaScript 中函數即對象,每定義一次就實例化一個對象:

alert(p1.sayName == p2.sayName); // false

把方法移到外部雖然能讓兩者共享,但代價是污染全域作用域,且方法一多就完全失去封裝:

function Person(name, age, job) {
  this.name = name;
  this.age = age;
  this.job = job;
  this.sayName = sayName;      // 指向全域函數
}
function sayName() { alert(this.name); }

原型鏈模式

每個函數都有一個 prototype 屬性,指向一個對象。這個對象的用途是存放可被子類型所有實例共享的屬性與方法。

function Person() { }

Person.prototype.name = "xxyh";
Person.prototype.age = 19;
Person.prototype.job = "programmer";
Person.prototype.sayName = function () { alert(this.name); };

var person1 = new Person();
person1.sayName();   // "xxyh"
var person2 = new Person();
person2.sayName();   // "xxyh"

alert(person1.sayName == person2.sayName); // true,共享同一個函數

理解原型對象

建立函數時會自動產生 prototype,而原型對象默認會獲得一個 constructor 屬性指回該函數,即 Person.prototype.constructor === Person。

呼叫構造函數創建實例時,實例內部會有一個指向原型對象的指針([[Prototype]],Firefox/Safari/Chrome 可以 __proto__ 存取)。這個連結存在於實例與構造函數的原型之間,而非實例與構造函數之間。

無法直接讀取 [[Prototype]],但可以用 isPrototypeOf() 檢測關係:

alert(Person.prototype.isPrototypeOf(person1)); // true
alert(Person.prototype.isPrototypeOf(person2)); // true

屬性查找與遮蔽

讀取屬性時會執行一次搜索,順序是:先在實例本身找,找到就回傳;沒找到則沿指針到原型對象找。

可以讀取原型中的值,但無法透過實例改寫原型中的值。在實例上設定同名屬性只會建立一個實例屬性,把原型屬性遮蔽掉:

Person.prototype.name = "xxyh";
var person1 = new Person();
var person2 = new Person();

person1.name = "oooo";
alert(person1.name);  // "oooo"  ← 實例屬性遮蔽了原型
alert(person2.name);  // "xxyh"  ← 原型不受影響

用 delete 移除實例屬性後,原型屬性會重新露出來:

delete person1.name;
alert(person1.name);  // "xxyh"

hasOwnProperty() 可以判斷屬性在哪一層:

alert(person1.hasOwnProperty("name")); // false,還在原型上
person1.name = "oooo";
alert(person1.hasOwnProperty("name")); // true,已成為實例屬性

原型與 in 操作符

單獨使用 in 時,只要對象能訪問到該屬性就回傳 true,不論它在實例還是原型上:

alert("name" in person1);  // true
person1.name = "oooo";
alert("name" in person1);  // true

搭配 hasOwnProperty 就能分辨:in 為 true 而 hasOwnProperty 為 false,即原型屬性。

function hasPrototypeProperty(object, name) {
  return !object.hasOwnProperty(name) && (name in object);
}

var person = new Person();
alert(hasPrototypeProperty(person, "name")); // true
person.name = "oooo";
alert(hasPrototypeProperty(person, "name")); // false

for...in 會回傳所有能訪問到的可枚舉屬性,包含實例與原型。要只取實例的可枚舉屬性,用 Object.keys():

var keys = Object.keys(Person.prototype);
alert(keys);            // name, age, job, sayName

var p1 = new Person();
p1.name = "oooo";
p1.age = 15;
alert(Object.keys(p1)); // name, age

要取得包含不可枚舉屬性的全部自有屬性,用 Object.getOwnPropertyNames():

alert(Object.getOwnPropertyNames(Person.prototype));
// "constructor,name,age,job,sayName"

更簡潔的原型語法

function Person() { }

Person.prototype = {
  name: "xxyh",
  age: 18,
  job: "programmer",
  sayName: function () { alert(this.name); }
};

結果相同,但有一個副作用:constructor 屬性不再指向 Person,因為整個原型對象被換成一個新的字面值對象,其 constructor 自然指向 Object。

var boy = new Person();
alert(boy instanceof Object);        // true
alert(boy instanceof Person);        // true
alert(boy.constructor == Person);    // false
alert(boy.constructor == Object);    // true

修正方式是在字面值中顯式補回:

Person.prototype = {
  constructor: Person,
  name: "xxyh",
  age: 18,
  job: "programmer",
  sayName: function () { alert(this.name); }
};

這個屬性通常不可枚舉,若在意可改用 Object.defineProperty 設定 enumerable: false。

原型修改的動態性

由於查找是一次實時搜索,對原型所做的任何修改都會立即反映到所有實例上。但整體替換原型對象則不同:實例的指針仍指向最初那個原型,替換等於切斷了它們與新原型之間的連結。

function Person() { }

var boy = new Person();          // 此時 boy 指向「最初的原型」

Person.prototype = {             // 換成新對象
  constructor: Person,
  name: "xxyh",
  sayName: function () { alert(this.name); }
};

boy.sayName();   // TypeError:sayName 不在 boy 所指向的舊原型上

結論:實例中的指針只指向原型,不指向構造函數。所以替換原型之前已建立的實例,永遠看不到新的原型。

原生對象的原型

所有原生引用類型的方法都定義在各自構造函數的原型上,因此你也可以擴充:

String.prototype.startsWith = function (text) {
  return this.indexOf(text) === 0;
};

var msg = "good morning";
alert(msg.startsWith("good"));   // true

(ES6 已內建 startsWith,此處僅作示範。)修改內建原型是爭議性做法:容易與其他庫衝突,也可能讓 for...in 出現意料外的屬性。除非是實作 polyfill,否則不建議這麼做。

原型模式的兩個問題

一是所有實例默認取得相同的值;二是原型上的屬性由所有實例共享。第二點對函數是優點,對可變資料則是災難:

Person.prototype = {
  constructor: Person,
  name: "xxyh",
  friends: ["張三", "李四"],
  sayName: function () { alert(this.name); }
};

var p1 = new Person();
var p2 = new Person();

p1.friends.push("王五");
alert(p1.friends);             // 張三,李四,王五
alert(p2.friends);             // 張三,李四,王五  ← 被連帶修改
alert(p1.friends === p2.friends); // true,同一個陣列

組合構造函數與原型

最常見的解法:構造函數負責實例屬性,原型負責方法與共享屬性。

function Person(name, age, job) {
  this.name = name;
  this.age = age;
  this.job = job;
  this.friends = ["張三", "李四"];
}

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

var p1 = new Person("蕭蕭弈寒", 18, "programmer");
var p2 = new Person("魁拔", 10, "捉妖");

p1.friends.push("王五");
alert(p1.friends);              // 張三,李四,王五
alert(p2.friends);              // 張三,李四
alert(p1.friends === p2.friends); // false,各自獨立
alert(p1.sayName === p2.sayName); // true,共享方法

這也是目前最廣泛使用的模式。

動態原型模式

把所有資訊封裝回構造函數內部,並在構造時檢查某個方法是否存在來決定是否初始化原型:

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

因為原型初始化只在第一次呼叫時發生,後續呼叫不再進入那個 if,所以幾乎沒有額外開銷。它同時保有兩種模式的優點,是很值得採用的折衷。

寄生構造函數模式

建立一個函數包住創建過程,最後回傳新對象:

function Person(name, age) {
  var obj = new Object();
  obj.name = name;
  obj.age = age;
  obj.sayName = function () { alert(this.name); };
  return obj;
}

var boy = new Person("xxyh", 19);
boy.sayName();

要注意的是,回傳的對象與構造函數及其原型沒有任何關聯,因此無法用 instanceof 判定類型。它的存在意義是在需要「返回非 this 對象」的特殊情境下(例如要回傳陣列或自訂展開的物件)提供一個寫法。

穩妥構造函數模式

穩妥對象指沒有公共屬性、方法也不引用 this 的對象。它與寄生模式類似,但有兩點差異:方法不引用 this,且不需用 new 調用。

function Person(name, age, job) {
  var obj = new Object();
  // 方法直接閉包 name,不透過 this
  obj.sayName = function () { alert(name); };
  return obj;
}

// 直接呼叫,不加 new
var person = Person("xxyh", 19, "programmer");
person.sayName();   // "xxyh"

適用於對安全性有疑慮的環境(例如沙箱),因為即使對象被丟進不可信的程式碼中,也不會透過 this 洩漏或讓外部改動內部狀態。缺點是每個實例的方法無法共享,記憶體開銷較大。

選型建議

  • 一般業務對象 → 組合模式(構造函數 + 原型),最實用。
  • 希望語意集中、單一構造函數搞定 → 動態原型模式。
  • ES6 可用 → 直接寫 class,語法糖背後就是原型,但可讀性與繼承寫法都更好。
  • 寄生與穩妥模式 → 只在特殊需求下使用,並接受 instanceof 失效的代價。
XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved