DIV CSS 佈局教程網

JavaScript 物件導向之我見:原型機制與類式模擬
編輯:JavaScript基礎知識     

序言

談 JavaScript 的物件導向,繞不開兩件事:一是它本質上是「基於原型」的物件導向語言,二是社群普遍在「模擬類語言」的寫法。

為什麼要模擬?我的看法是:原型模式在輕量場景下很方便,但在複雜應用裡,它在抽象性與繼承性上都顯得吃力。而 JavaScript 又是唯一被各家瀏覽器普遍支援的腳本語言,於是各路高手只能用各種手法補齊便利性,寫出來的程式碼越來越像類語言,反而把 JavaScript 原型系統的本質給蓋住了。

基於原型的物件導向語言

原型模式與類模式同屬一種「程式設計泛型」,也就是方法論;近來聲勢很旺的函數式程式設計也是一類。Brendan Eich 設計 JavaScript 時,從一開始就沒打算加入類別,而是借鑑了 Self 與 Smalltalk 這兩門基於原型的語言。

既然都是物件導向,就得有建立物件的方式。類語言先定義類別作為現實世界的抽象,再由類別 instance 化物件;原型語言則是複製另一個物件,被複製的那個稱為原型物件。

複製的關鍵在於語言是否原生支援。ES5 提供了 Object.create:

var person = { name: "tree", age: 25, say: function(){ console.log("I'm tree.") } };
var cloneTree = Object.create(person);
console.log(cloneTree);

原型模式的目的不是得到一個一模一樣的複本,而是提供一種便利的建立物件方式。但由於語言設計上的歷史包袱,JavaScript 的原型存在不少矛盾,那些看起來很像類語言的語法,反而掩蓋了它的原型機制:

function Person(name, age){ this.name = name; this.age = age; }
var p = new Person('tree', 25)

實際上,當函式物件被建立時,Function 建構器會執行類似這樣的程式碼:

this.prototype = { constructor: this }

新函式被賦予一個 prototype 屬性,其值是一個帶有 constructor(指向該函式)的物件。對函式使用 new 時,prototype 的值就被當作原型來複製新物件。若把 new 想成一個方法,它大致是這樣:

Function.prototype.new = function() {
  // 以 prototype 屬性值作為原型複製一個新物件
  var that = Object.create(this.prototype);
  // 改變函式中 this 的指向,指向這個新物件
  var other = this.apply(that, arguments);
  // 若回傳值不是物件,則回傳這個新物件
  return (other && typeof other === 'object') ? other : that;
}

也就是說,new 看起來像模板 instance 化,本質仍是「以原型物件複製出新物件」。加上新物件能沿原型鏈存取原型上的一切屬性與方法,這就成了用原型模擬類式語言的基石。

用原型模擬類式語言

抽象

慣例是把「欄位」放進建構函式(嚴格說那是被 new 呼叫的函式,JavaScript 本身沒有建構函式的概念),把「方法」掛在 prototype 上。

function Person(name, age) {
  this.name = name;
  this.age = age;
};
Person.prototype.say = function(){
  console.log("Hello, I'm " + this.name);
};

繼承

繼承是 OO 語言最常被討論的題目。接口繼承只繼承方法簽名,實現繼承繼承實際方法。ECMAScript 因為函式沒有簽名,無法實現接口繼承,只支援實現繼承,且主要依賴原型鏈。高階程式設計一書中探索了組合繼承、原型繼承、寄生繼承、寄生組合繼承等模擬方式,最後仍以寄生組合式作為各類模擬的基礎。

function Person(name, age) { this.name = name; this.age = age; };
Person.prototype.say = function(){ console.log("Hello, I'm " + this.name); };

function Employee(name, age, major) {
  Person.apply(this, arguments);
  this.major = major;
};
Employee.prototype = Object.create(Person.prototype);
Employee.prototype.constructor = Employee;
Employee.prototype.sayMajor = function(){ console.log(this.major); }

書中只給了單繼承。多繼承得自己想辦法,而它天生有障礙:任何支援多繼承的語言都會遇上著名的「菱形問題」。若 O 有個方法 foo,被 A、B 各自覆寫而 C 沒有覆寫,那 C 呼叫 foo 時該走 A 還是 B?

多數語言因此只支援單繼承(如 Java 單繼承+介面)。JavaScript 連介面都沒有,要模擬就只能靠鴨子式定型,落到程式碼上就是混入(mixin):

function mixin(t, s) {
  for (var p in s) { t[p] = s[p]; }
}

另外,dojo 用 MRO(方法解析順序)的方式處理了多繼承問題。

打造自己的類別建立工具

釐清原理後,我替自己定了幾個目標:

  • 提供便利的建立類別方式,而不暴露函式的 prototype。
  • 子類覆寫父類方法時,能像 Java 那樣用 super 直接呼叫父類同名方法。
  • 更簡便地加上靜態變數與方法,不必操心 prototype。
  • 像 C# 那樣支援 Attribute。

最後寫成了 O.js:

(function(global) {
  var define = global.define;
  if (define && define.amd) {
    define([], function(){ return O; });
  } else {
    global.O = O;
  }
  function O(){};
  O.derive = function(sub) {
    var parent = this;
    sub = sub ? sub : {};
    var o = create(parent);
    var ctor = sub.constructor || function(){};
    var statics = sub.statics || {};
    var ms = sub.mixins || [];
    var attrs = sub.attributes || {};
    delete sub.constructor;
    delete sub.mixins;
    delete sub.statics;
    delete sub.attributes;
    // 處理繼承關係
    ctor.prototype = o;
    ctor.prototype.constructor = ctor;
    ctor.superClass = parent;
    // 以 defineProperties 處理 attributes
    Object.defineProperties(ctor.prototype, attrs);
    // 靜態屬性
    mixin(ctor, statics);
    // 混入其他屬性與方法,這裡的屬性所有實例都能存取並修改
    mixin(ctor.prototype, sub);
    // 以 mixin 模擬多繼承
    for (var i = 0, len = ms.length; i < len; i++) {
      mixin(ctor.prototype, ms[i] || {});
    }
    ctor.derive = parent.derive;
    // _super 函式
    ctor.prototype._super = function(f) {
      return parent.prototype[f].apply(this, Array.prototype.slice.call(arguments, 1));
    }
    return ctor;
  }
  function create(clazz) {
    var F = function(){};
    F.prototype = clazz.prototype;
    return new F();
  }
  function mixin(t, s) {
    for (var p in s) { t[p] = s[p]; }
  }
})(window);

建立類別:

var Person = O.derive({
  constructor: function(name) {   // 建構函式
    this.setInfo(name);
  },
  statics: {                      // 靜態變數
    declaredClass: "Person"
  },
  attributes: {                   // 模擬 C# 的屬性
    Name: {
      set: function(n) { this.name = n; console.log(this.name); },
      get: function() { return this.name + "Attribute"; }
    }
  },
  share: "asdsaf",                // 位於原型上,所有物件共享
  setInfo: function(name) {       // 方法
    this.name = name;
  }
});
var p = new Person('lzz');
console.log(p.Name);  // lzzAttribute

繼承:

var Employee = Person.derive({
  constructor: function(name, age) {
    this.setInfo(name, age);
  },
  statics: { declaredClass: "Employee" },
  setInfo: function(name, age) {
    this._super('setInfo', name);  // 呼叫父類同名方法
    this.age = age;
  }
});
var e = new Employee('lll', 25);
console.log(e.Name);  // lllAttribute

參考:《JavaScript 語言精粹》、《JavaScript 設計模式與開發實踐》、《JavaScript 高階程式設計(第三版)》,以及 Douglas Crockford 關於原型繼承與古典繼承的兩篇文章。

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