DIV CSS 佈局教程網

深入理解建構函數與原型物件
編輯:關於JavaScript     

常見的幾種物件建立模式

使用 new 關鍵字

最基礎的方式,與多數語言相同:沒物件,new 一個就好。

var gf = new Object();
gf.name = "tangwei";
gf.bar = "c++";
gf.sayWhat = function() {
  console.log(this.name + " said: love you forever");
};

使用字面量

這樣似乎夠了,但 geek 們不會滿足於如此冗長的寫法。作為一門腳本語言,理該有更俐落的姿態,於是有了物件字面量:

var gf = {
  name: "tangwei",
  bar: "c++",
  sayWhat: function() {
    console.log(this.name + " said: love you forever");
  }
};

工廠模式

實務中最常用到的場景是「我要產生一堆屬性結構相似的物件」。若一個一個定義,程式碼會迅速膨脹,不如蓋一座工廠批量生產:

function createGf(name, bar) {
  var o = new Object();
  o.name = name;
  o.bar = bar;
  o.sayWhat = function() {
    alert(this.name + " said: love you forever");
  };
  return o;
}
var gf1 = createGf("bingbing", "d");
var gf2 = createGf("mimi", "a");

工廠模式解決了多個相似物件的建立問題,但新問題是:這些物件全是 Object 做出來的,該怎麼區分它們的具體型別?

建構函數模式

function Gf(name, bar){
  this.name = name;
  this.bar = bar;
  this.sayWhat = function(){
    alert(this.name + " said: love you forever");
  };
}
var gf1 = new Gf("vivian", "f");
var gf2 = new Gf("vivian2", "f");

這裡改用大寫開頭的建構函數(慣例如此)取代 createGf:建立一個新物件,把建構函數的作用域指派給它,再執行建構函數中的程式碼。這個做法讓每個物件都有明確的型別歸屬。

但仔細看會發現一個浪費:兩個實例呼叫的 sayWhat 並不是同一個 Function 實例:

console.log(gf1.sayWhat == gf2.sayWhat); // false

呼叫同一個方法卻各自建立一份實例,明顯浪費資源。直覺的解法是把 sayWhat 移到建構函數外面宣告:

function Gf(name, bar){
  this.name = name;
  this.bar = bar;
  this.sayWhat = sayWhat;
}
function sayWhat(){
  alert(this.name + " said: love you forever");
}

問題解決了,但新問題又來:這個 sayWhat 是全域函數,實際上並不適合成為全域資產,某種程度上顯得矛盾——它明明只服務 Gf。想要優雅地定義一個具備封裝性的物件,就得看原型物件模式。

理解原型物件

建立一個函數時,該函數會具備一個 prototype 屬性,指向「透過此建構函數建立的那些物件所共享的原型物件」。通俗地說,原型物件就是記憶體中為其他物件提供共用屬性與方法的物件。

在原型模式中,不必在建構函數裡定義屬性,直接把資訊掛到原型上即可:

function Gf(){}
Gf.prototype.name = "vivian";
Gf.prototype.bar = "c++";
Gf.prototype.sayWhat = function(){
  alert(this.name + " said: love you forever");
};

var gf1 = new Gf();
gf1.sayWhat();
var gf2 = new Gf();

與建構函數不同,這裡的屬性與方法由所有實例共享——gf1 與 gf2 存取的是同一份。除了我們掛上去的屬性,原型物件還有內建的 constructor,它是一個指向「擁有該 prototype 屬性的函數」的指標。整理成流程如下:

所有物件都有一個原型物件;原型物件上的 constructor 指回包含它的函數;Gf 的實例 gf1 與 gf2 各自有一個內部連結指向原型(Firefox 中表現為私有屬性 __proto__)。當我們存取某個屬性時,引擎先問實例本身有沒有,沒有就沿著連結往原型找——這就是屬性查找的基本順序。

用字面量定義原型

每次都寫 Gf.prototype.xxx 相當累贅,可以改用字面量一次定義:

function Gf(){}
Gf.prototype = {
  name: "vivian",
  bar: "c++",
  sayWhat: function(){
    alert(this.name + " said: love you forever");
  }
};

這裡有個容易忽略的細節:constructor 不再指向 Gf。因為每定義一個函數,引擎會自動為它建立 prototype 並掛上 constructor;而我們用字面量整個覆寫了 prototype,新字面量並沒有 constructor,於是會沿原型鏈找到 Object.prototype.constructor:

var gf1 = new Gf();
console.log(gf1.constructor == Gf);     // false
console.log(gf1.constructor == Object); // true

一般情況下這個微妙變化不影響任何功能,但若程式碼依賴 constructor 做型別判斷,就必須手動補回:

Gf.prototype = {
  constructor: Gf,
  name: "vivian",
  bar: "c++",
  sayWhat: function() {
    alert(this.name + " said: love you forever");
  }
};
var gf1 = new Gf();
console.log(gf1.constructor == Gf); // true

說到底,原型模式的基本特點就是「所有實例共用同一份屬性」,這對開發者是一把雙面刃:我們通常希望每個實例擁有自己的資料。這也正是實務上很少單獨使用原型模式的主要原因。

建構函數與原型組合模式

標準解法是把兩者放在一起:用建構函數定義實例各自的屬性,用原型定義共用的方法:

function Gf(name, bar){
  this.name = name;
  this.bar = bar;
}
Gf.prototype = {
  constructor: Gf,
  sayWhat: function() {
    alert(this.name + " said: love you forever");
  }
};

var gf1 = new Gf("vivian", "f");
var gf2 = new Gf("vivian1", "c");

屬性在構造函數中各自定義,因此 gf1 與 gf2 互不影響;sayWhat 掛在原型上,所有實例共用同一份函數,既省記憶體也便於集中維護。這是實務上最常用的物件定義方式,包括 jQuery 插件、Bootstrap 等許多早期函式庫的元件建構,走的都是這條路。

補充一句現況:ES6 的 class 語法本質上就是這套組合模式的標準化寫法——constructor 裡的賦值對應實例屬性,方法宣告則自動掛到 prototype 上,因此不需要再手動處理 constructor 指向的問題。理解原型的存在,才能在遇到「為什麼改了原型,所有實例都變了」這類問題時迅速定位。

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