DIV CSS 佈局教程網

JavaScript 物件導向程式設計深度解析:原型、繼承與類別模擬
編輯:關於JavaScript     

前言

在 JavaScript 的世界裡談物件導向,繞不開兩個前提:其一,JavaScript 是一門基於原型的物件導向語言;其二,實務上大量存在的寫法是在模擬類別語言的物件導向方式。

為什麼要模擬類別語言?我的看法是:原型模式在特定情境下確實便利,但在複雜應用中,純原型系統在抽象性與繼承性上力有未逮。而 JavaScript 又是唯一被各大瀏覽器原生支援的腳本語言,於是各路高手不得不想辦法提升它的便利性,結果就是程式碼越寫越像類別語言,反而掩蓋了 JavaScript 原型系統的本質。

基於原型的物件導向語言

原型模式與類模式都是一種程式設計泛型,也就是方法論;近來蔚為風潮的函數式程式設計同樣也是一種泛型。JavaScript 之父 Brendan Eich 從一開始就沒打算加入類別概念,而是借鑑了 Self 與 Smalltalk 這兩門基於原型的語言。

既然同為物件導向,就得有建立物件的方法。類語言中,物件由模板建立:先定義類作為現實世界的抽象,再由類 instance 化物件。而在原型語言中,物件是以複製另一個物件的方式誕生,被複製的母體稱為原型物件。

複製的關鍵在於語言是否提供原生複製能力。ECMAScript 5 的 Object.create 就肩負這個職責:

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

var cloneTree = Object.create(person);
console.log(cloneTree);

原型模式的目的並不在得到一個一模一樣的複製品,而是提供一種便捷的建構方式(出自《JavaScript 設計模式與開發實踐》)。但由於語言設計的歷史包袱,JavaScript 的原型存在諸多矛盾,某些語法看起來就像類語言,反而遮蔽了原型機制(出自《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 的特性,慣例是把欄位放在建構函式(實為被 new 呼叫的普通函式)中,把方法放在 prototype 上:

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

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

繼承

繼承是 OO 語言中最常被討論的概念。多數 OO 語言支援兩種繼承:介面繼承(只繼承方法簽名)與實作繼承(繼承實際方法)。ECMAScript 無法實作介面繼承,只支援實作繼承,且主要依賴原型鏈(《JavaScript 高級程式設計》6.3 節)。書中探討了組合繼承、原型繼承、寄生繼承、寄生組合繼承等模擬方式,最終寄生組合式成為所有類式繼承模擬的基礎:

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

書中只給了單繼承方案,多繼承得自己想辦法。而多繼承本身就困難:支援多繼承的語言都會遇上著名的菱形問題(Diamond Problem)。若 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(Method Resolution Order,方法解析順序)的方式解決了多繼承問題。

打造自己的類別建立工具

理清了原理,作為一個愛折騰的開發者,我希望有更簡便的方式建立類別,目標有四:

  • 提供便利的類別建立方式,而不暴露函式的 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);

    // 混入其他屬性與方法,注意這裡的屬性是所有 instance 都能存取並修改的
    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", // 位於原型上的變數,所有 instance 共享
  setInfo: function (name) { // 方法
    this.name = name;
  }
});

var p = new Person('lzz');
console.log(p.Name); // lzzAttribute
console.log(Person);

繼承則顯得相當直觀:

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
console.log(Employee);

理解原型機制之後,這些看似神奇的語法糖其實都很透明——它們不過是原型鏈、混入與 Object.create 的組合技。掌握底層原理,框架層的設計自然就有跡可循。

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