DIV CSS 佈局教程網

JavaScript 實現繼承的三種方式:類式、原型式與摻元類
編輯:關於JavaScript     

JavaScript 是物件導向語言,但它的繼承機制從設計之初就與傳統的類別式語言不同——它採用的是基於原型的繼承。在這個機制之上,社群發展出幾種不同的實作方式,各有取捨。本文逐一拆解。

方法一:類式繼承

所謂類式繼承,就是模仿傳統物件導向語言的繼承形式,讓繼承的雙方都呈現「類」的樣貌。

先定義父類:

function Person(name) {
  this.name = name;          // 寫在建構器裡:每個實例各自獨立
}
Person.prototype.getName = function () {
  return this.name;
};

這個設計有兩個刻意的選擇。屬性寫在建構器中,可以保證繼承它的子類擁有獨立的 name,不與父類共用;方法掛在 prototype 上,則是為了讓所有實例共用同一份函數——每次 new 出來的實例,其 getName 都參照同一段記憶體空間,而不是各自複製一份。

再定義繼承函式:

function extend(subClass, superClass) {
  var F = function () {};
  F.prototype = superClass.prototype;   // F 的原型指向父類原型
  subClass.prototype = new F();         // 子類原型指向 F 的實例
  subClass.prototype.constructor = subClass;
  subClass.superClass = superClass.prototype;

  if (superClass.prototype.constructor == Object.prototype.constructor) {
    superClass.prototype.constructor = superClass;
  }
}

這段程式碼的巧妙之處在於引入一個空的過渡建構器 F。如果直接寫 subClass.prototype = new superClass(),就會呼叫父類建構器,可能產生副作用(例如需要參數卻沒傳)。用空的 F 承接父類原型,就能建立原型鏈而不觸發父類建構器。

另外三行是修補工作:因為 prototype 被整體替換,原本正確的 constructor 指向就丟了,要手動補回子類;superClass 屬性則是給子類一個呼叫父類的通道。

定義子類並繼承:

function Author(name, books) {
  Author.superClass.constructor.call(this, name);   // 借用父類建構器
  this.book = books;                                 // 自己的屬性
}
extend(Author, Person);

Author.prototype.getBooks = function () {
  return this.book;
};

子類建構器中透過 superClass.constructor.call(this, name) 呼叫父類建構器,並用 call 把 this 的指向轉換為當前子類實例。這一手法稱為「借用建構器」,讓子類取得父類在該建構器中定義的屬性。extend() 則負責接上原型鏈,繼承父類原型上的方法。最後子類掛上自己的 getBooks,完成擴充。

取捨:優點是對習慣傳統物件導向概念的開發者非常直觀。缺點是過程繁瑣、記憶體消耗稍大——子類有自己的建構器與原型,且父子屬性完全隔離,即使值相同也無法共用記憶體。

方法二:原型式繼承

用物件字面量定義父類:

var Person = {
  name: 'default name',
  getName: function () { return this.name; }
};

定義克隆函式:

function clone(obj) {
  function F() {}
  F.prototype = obj;      // 把新物件原型指向父類
  return new F();
}

這裡的關鍵是:回傳的物件本身沒有任何自有屬性,所有存取都透過原型鏈委派給父類。

子類透過克隆繼承:

var Author = clone(Person);
Author.book = ['javascript'];
Author.showBook = function () { return this.book; };

此時 Author 透過原型鏈擁有 name 屬性,值與父類相同,因此沒有覆寫。若要給子類不同的值,直接賦值即可:

Author.name = 'new name';

取捨:相比類式繼承,原型式繼承更簡潔自然。若子類的屬性值與父類相同而不需修改,兩者實際上共用同一段記憶體。缺點是對習慣傳統物件導向的開發者較難理解。若要在兩者間選擇,這種方式通常更優秀。

值得注意的是,ES5 已經把這個模式標準化為 Object.create():

var Author = Object.create(Person);

方法三:摻元類實現多重繼承

問題在於:JavaScript 中每個物件的原型只能指向單一對象,無法指向多個,那要怎麼實現多重繼承?

《JavaScript 設計模式》一書提出了摻元類(mixin class)的解法。思路是:定義一些可重複使用的類別,把其中的方法與屬性「複製」到其他類別的原型上。若同時摻入多個,該類別就間接實現了多重繼承。

定義摻元類:

var Mixin = function () {};
Mixin.prototype = {
  serialize: function () {
    var output = [];
    for (key in this) {
      output.push(key + ":" + this[key]);
    }
    return output.join(',');
  }
};

這個 serialize 方法會遍歷自身屬性,組合成字串回傳。

定義擴充函式:

function augment(receivingClass, givingClass) {
  if (arguments[2]) {
    // 只拷貝指定的屬性 / 方法
    for (var i = 2, len = arguments.length; i < len; i++) {
      receivingClass.prototype[arguments[i]] = givingClass.prototype[arguments[i]];
    }
  } else {
    // 拷貝全部(不覆蓋接收方已有的成員)
    for (methodName in givingClass.prototype) {
      if (!receivingClass.prototype[methodName]) {
        receivingClass.prototype[methodName] = givingClass.prototype[methodName];
      }
    }
  }
}

這個函式預設兩個參數:接收擴充的類別,以及提供能力的摻元類。若傳入第三個起的參數,就只拷貝那些指名的方法或屬性;否則拷貝全部。本質上是把摻元類原型上的成員搬到接收類的原型上。

使用擴充達成多重繼承:

augment(Author, Mixin);

var author = new Author('js', ['javascript design patterns']);
alert(author.serialize());

執行結果如下:

可以看到這個物件同時具備了 Person、Author 與 Mixin 三者的屬性與方法。其中 Person 的能力來自原型式繼承,Mixin 的能力來自摻元,從實際效果上講,它實現了多重繼承。若需要更多能力,只要再定義更多摻元類並逐一 augment 即可。

三種方式的總結比較

方式核心機制優點缺點
類式繼承 過渡建構器接上原型鏈 + 借用建構器 概念直觀,父子屬性獨立 程式碼繁瑣,記憶體消耗較大
原型式繼承 Object.create 語義,原型委派 簡潔自然,可共用記憶體 直覺性較差,屬性容易意外共用
摻元類 把成員複製到原型上 可組合多個來源,實現多重繼承 是複製而非委派,方法衝突需自行處理

現代寫法:class 語法

ES6 的 class 語法本質上是原型繼承的語法糖,底層機制與上述相同,但可讀性大幅提升:

class Person {
  constructor(name) {
    this.name = name;
  }
  getName() { return this.name; }
}

class Author extends Person {
  constructor(name, books) {
    super(name);
    this.book = books;
  }
  getBooks() { return this.book; }
}

如果要組合多個來源的行為,ES2015 之後的做法通常是 Object.assign() 搭配 mixin 函式,或直接改用組合(composition)取代繼承——把能力當成元件注入,而非沿著原型鏈往上找。這是現代 JavaScript 設計思潮的明顯轉向:「優先組合而非繼承」,因為它避免了深層原型鏈帶來的脆弱基類問題。

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