DIV CSS 佈局教程網

JavaScript 物件導向全解:從建立物件到寄生組合式繼承
編輯:JavaScript綜合知識     

JavaScript 沒有 class 關鍵字(ES6 之前),卻要做物件導向。這個落差催生了各種建立物件與實作繼承的模式。本文依序走過:建立物件的五種方式、原型的運作、以及繼承的七種做法,最後說明為什麼「寄生組合式繼承」被視為最優解。

一、建立物件的五種模式

1. 直接建立:直白但無法 reuse

var box = new Object();
box.name = 'lee';
box.age = 100;
box.run = function () { return this.name + this.age + '運行中...'; }

想建第二個類似物件,就得把整段複製一遍。

2. 工廠模式:把重複收進函式

function createObject(name, age) {
  var obj = new Object();
  obj.name = name;
  obj.age = age;
  obj.run = function () { return this.name + this.age + "運行中..."; };
  return obj;
}
var box1 = createObject("lee", 100);
var box2 = createObject("jack", 200);

缺點是無法辨識物件身分——typeof box1 只會回傳 "object",看不出它是哪個類型的實例。

3. 建構函式:可辨識身分

function Box(name, age) {
  this.name = name;
  this.age = age;
  this.run = function () { return this.name + this.age + "運行中..."; };
}
var box1 = new Box("lee", 100);
console.log(box1 instanceof Box);   // true,身分清楚

與工廠模式的三點差異:沒有明確建立物件(不用 new Object)、直接把屬性與方法賦值給 this、沒有 return 語句。

慣例:函式名稱首字母大寫,且必須搭配 new 呼叫。若忘記 new,this 會指向全域物件,屬性被寫到 window 上,且回傳 undefined。

4. 建構函式的根本問題

用建構函式時,每個實例都會重新建立一份方法。因為函式在 JavaScript 中就是物件,每定義一次函式等於建立一個新物件。這造成兩份 box1.run 與 box2.run 雖然內容相同,卻是不同的參照:

var b1 = new Box('a', 1), b2 = new Box('b', 2);
console.log(b1.run === b2.run);   // false

這正是原型要解決的問題。

二、原型(Prototype)

每個函式都有一個 prototype 屬性,指向一個物件。它的用途是存放可讓該型別所有實例共享的屬性與方法。

function Box() {}
Box.prototype.name = 'Lee';
Box.prototype.age = 100;
Box.prototype.run = function () { return this.name + this.age + '運行中...'; };

var box1 = new Box();
var box2 = new Box();
console.log(box1.run === box2.run);   // true,共用同一個參照

屬性查找順序

讀取 box1.name 時:

  1. 先在實例自身的屬性中找,找到立刻回傳。
  2. 沒有則沿 __proto__ 爬到原型物件上找。
  3. 還沒有就繼續往 Object.prototype,最後是 null。

因此實例屬性會遮蔽(shadow)原型屬性:

var b1 = new Box();
console.log(b1.name);   // Lee(來自原型)
b1.name = 'jack';
console.log(b1.name);   // jack(實例自己的)
delete b1.name;
console.log(b1.name);   // Lee(又看到原型了)

兩個內建屬性

__proto__ 是實例指向原型的指針(標準做法是 Object.getPrototypeOf())。constructor 是原型上的屬性,指回建構函式本身。

判斷原型關係用 isPrototypeOf():

Box.prototype.isPrototypeOf(box1);   // true

in 運算子與 hasOwnProperty

console.log(box.hasOwnProperty('name'));  // 只問實例自身
console.log('name' in box);                 // 實例或原型有就算 true

字面量語法與 constructor 陷阱

Box.prototype = {
  constructor: Box,        // 必須手動補回,否則會指向 Object
  name: 'Lee',
  age: 100,
  run: function () { return this.name + this.age; }
};

整體覆寫原型會切斷 constructor 的正確指向,因為字面量 {} 本身就是建立一個新物件,其 constructor 預設為 Object。若不補回,box.constructor == Box 會是 false。

另一個後果:覆寫原型會切斷與既有實例的連結。覆寫之前建立的物件仍指向舊的原型物件。

原型模式的最大問題:引用型別共享

Box.prototype.family = ['father', 'mother'];
var b1 = new Box(), b2 = new Box();
b1.family.push('sister');
console.log(b2.family);   // ["father","mother","sister"] — 被汙染了

所有實例共用同一個陣列,一邊改動其他邊全變。此外原型模式也無法在建構時傳入參數初始化。

解法:組合模式(最常用)

function Box(name, age) {          // 不共享的屬性放這裡
  this.name = name;
  this.age = age;
  this.family = ['father', 'mother'];
}
Box.prototype = {                  // 共享的方法放這裡
  constructor: Box,
  run: function () { return this.name + this.age + this.family; }
};

動態原型模式

把原型封裝進建構函式裡,只在第一次執行時初始化:

function Box(name, age) {
  this.name = name;
  this.age = age;
  if (typeof this.run !== "function") {
    Box.prototype.run = function () { return this.name + this.age; };
  }
}

注意:此模式下不可再用字面量覆寫原型,否則會切斷連結。

寄生建構函式

本質是工廠模式包在建構函式外殼裡,能傳參,但無法可靠辨識物件身分:

function Box(name, age) {
  var obj = new Object();
  obj.name = name;
  obj.age = age;
  obj.run = function () { return this.name + this.age; };
  return obj;
}

三、繼承的七種做法

1. 原型鏈

把父類型的實例賦值給子類型的 prototype:

function Box() { this.name = 'Lee'; }
function Desk() { this.age = 100; }

Desk.prototype = new Box();      // 關鍵一行

var desk = new Desk();
console.log(desk.age);    // 100(自己的)
console.log(desk.name);   // Lee(從 Box 繼承而來)

可以再串一層:Table.prototype = new Desk();,形成 Box → Desk → Table 的鏈條,最終都繼承自 Object。

問題:引用型別共享(與原型模式同一個病),且無法向父類建構函式傳參。

2. 借用建構函式(物件冒充)

在子類建構函式內呼叫父類,用 call 改變 this:

function Box(age) {
  this.name = ['Lee', 'Jack'];
  this.age = age;
}
function Desk(age) {
  Box.call(this, age);    // 繼承 Box,並成功傳參
  this.height = 175;
}
var desk = new Desk(200);
desk.name.push('AAA');    // 只影響 desk 自己,不汙染原型

解決了引用共享與傳參問題,但方法無法複用——每次都重新建立,函式復用無從談起。

3. 組合繼承(原型鏈 + 借用建構函式)

function Box(age) {
  this.name = ['Lee', 'Jack'];
  this.age = age;
}
Box.prototype.run = function () { return this.name + this.age; };  // 方法給原型

function Desk(age) {
  Box.call(this, age);        // 屬性用借用建構函式
}
Desk.prototype = new Box();   // 方法用原型鏈

var desk = new Desk(100);
console.log(desk.run());

這是最常用的繼承模式,但仍有個缺陷:Box 被呼叫了兩次——一次在 Desk.prototype = new Box(),一次在 Box.call(this, age)。

4. 原型式繼承

function obj(o) {
  function F() {}
  F.prototype = o;
  return new F();
}

var box = { name: 'Lee', arr: ['brother', 'sister'] };
var box1 = obj(box);
box1.arr.push('father');     // 引用型別仍然共享

本質是對傳入物件做一次淺複製,不必預先定義建構函式。ES5 之後直接用 Object.create(box) 即可。

5. 寄生式繼承

原型式加上工廠模式,目的是把建立物件的過程封裝起來,回傳增強後的物件。引用共享的問題依舊存在。

6. 寄生組合式繼承(最優解)

思路:用借用建構函式繼承屬性,用原型鏈的淺複製繼承方法,藉此避免呼叫父類建構函式兩次。

function obj(o) {
  function F() {}
  F.prototype = o;
  return new F();
}

function inheritPrototype(subType, superType) {
  var f = obj(superType.prototype);   // 複製父類原型,不執行建構函式
  f.constructor = subType;            // 修正 constructor 指向
  subType.prototype = f;              // 指定為子類原型
}

function Box(name) {
  this.name = name;
  this.arr = ['brother', 'sister'];
}
Box.prototype.run = function () { return this.name; };

function Desk(name, age) {
  Box.call(this, name);               // 只呼叫一次,屬性獨立
  this.age = age;
}
inheritPrototype(Box, Desk);

var desk = new Desk('Lee', 100);
desk.arr.push('father');
console.log(desk.run());              // Lee

它結合了組合繼承的優點,又消除了多餘的一次建構函式呼叫,是衡量「繼承是否正確實作」的標準答案。ES6 的 class extends 底層就是這個模式。

四、總結對照

建立物件

物件在 JavaScript 中是動態的,執行時可以增強,而非嚴格定義的實體。工廠模式用函式建立並回傳物件,後來被建構函式取代;建構函式能自定義引用類型並用 new 建立實例,但成員無法複用;原型模式透過 prototype 指定共享成員,實務上與建構函式組合使用——建構函式管實例屬性,原型管共享方法。

繼承

原型鏈由「把一個類型的實例賦值給另一個建構函式的 prototype」構成,子類型能存取超類型的所有成員,但共享問題使他不適合單獨使用。借用建構函式在子類型建構時呼叫超類型,讓每個實例擁有獨立屬性。組合繼承結合兩者,是最常用的模式;寄生組合式繼承則進一步消除重複呼叫,是基於類型的繼承中最有效率的做法。

一句話選型建議

新專案直接用 ES6 class 與 extends,語法清楚且就是上述模式的標準化;需要混入多個行為時用 Object.assign 搭配 mixin;只有在維護舊程式或面試需要說明原理時,才需要手寫這些模式。理解它們的價值在於——你會知道 class 底下正在發生什麼事。

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