DIV CSS 佈局教程網

JavaScript 類封裝完全解析:五個 Class 機制的原始碼剖析
編輯:關於JavaScript     

JavaScript 的入門門檻很低,一個從沒寫過它的人,幾小時內也能弄出一段堪用的小程式。但若因此認為它是門簡單的語言,那就大錯特錯了——想寫出高效能的程式碼,需要的是與撰寫 Java、C++ 同等的素養。一位 Java 工程師未必寫得出好的 JavaScript,但相對於毫無物件導向經驗的人,他確實更容易寫好。

JavaScript 的「簡單」源自它極強的包容性:宣告時不必指定型別,型別也能任意轉換;它支援物件導向,卻沒有 class 這個關鍵字。它崇尚自由,卻 also 要求嚴謹。

為什麼要封裝 Class

JavaScript 的物件導向與 Java、C++ 最大的差異在於繼承方式:它基於原型(prototype)鏈,所有物件最終都追溯到 Object。本文不打算比較各家繼承模型的優劣,而是聚焦在一個實務問題:如何封裝 class,以便更好地管理與維護基礎程式碼、減少重複、並走向模組化。以下整理五個在 GitHub 上評價不錯的方案。

一、MY-CLASS

專案位址:https://github.com/jiem/my-class

建立類別

(function(){
  var Person = my.Class({
    STATIC: { AGE_OF_MAJORITY: 18 },        // 靜態成員
    constructor: function(name, age){       // 建構子
      this.name = name;
      this.age  = age;
    },
    sayHello: function(){
      console.log('Hello from ' + this.name + '!');
    },
    drinkAlcohol: function(){
      this.age < Person.AGE_OF_MAJORITY
        ? console.log('Too young! Drink milk instead!')
        : console.log('Whiskey or beer?');
    }
  });
  myLib.Person = Person;
})();

var john = new myLib.Person('John', 16);
john.sayHello();      // Hello from John!
john.drinkAlcohol();  // Too young! Drink milk instead!

繼承類別

(function(){
  var Dreamer = my.Class(Person, {
    constructor: function(name, age, dream){
      Dreamer.Super.call(this, name, age);   // 呼叫父類建構子
      this.dream = dream;
    },
    sayHello: function(){
      superSayHello.call(this);
      console.log('I dream of ' + this.dream + '!');
    },
    wakeUp: function(){ console.log('Wake up!'); }
  });
  var superSayHello = Dreamer.Super.prototype.sayHello;
  myLib.Dreamer = Dreamer;
})();

var sylvester = new myLib.Dreamer('Sylvester', 30, 'eating Tweety');

為既有類別擴充方法

my.extendClass(myLib.Dreamer, {
  STATIC: { s_doSomething: function(){ console.log("do something!"); } },
  touchTheSky:   function(){ console.log('Touching the sky'); },
  reachTheStars:function(){ console.log('She is so pretty!'); }
});

實作(混入)另一個類別的方法

myLib.ImaginaryTraveler = my.Class({
  travel:      function(){ console.log('Traveling on a carpet!'); },
  crossOceans: function(){ console.log('Saying hi to Moby Dick!'); }
});

var Dreamer = my.Class(Person, ImaginaryTraveler, {
  constructor: function(name, age, dream){
    Dreamer.Super.call(this, name, age);
    this.dream = dream;
  }
});
var aladdin = new Dreamer('Aladdin');
aladdin instanceof Person;            // true
aladdin instanceof ImaginaryTraveler; // false(混入不影響原型鏈)

原始碼要點

my.Class 用「參數個數」決定行為:只有一個參數時建立基礎類;兩個參數時第一個為父類;三個以上時,第一個是父類、最後一個是本類定義,中間的則是待混入的類別。它透過一個空的媒介建構子銜接原型以解除引用,並同時處理靜態成員的拷貝,且同時支援 CommonJS 與瀏覽器環境(含 AMD define)。

二、KLASS

專案位址:https://github.com/ded/klass

// 建立類別
var Person = klass(function(name){
  this.name = name
})
.statics({ head: ':)', feet: '_|_' })   // 靜態方法
.methods({ walk: function(){} });       // 實例方法

// 繼承
var SuperHuman = Person.extend(function(name){
  // 自動呼叫父類建構子
}).methods({
  walk: function(){
    this.supr();     // 明確呼叫父類的 walk
    this.fly();
  },
  fly: function(){}
});
new SuperHuman('Zelda').walk();

// 字面量宣告
var Foo = klass({
  foo: 0,
  initialize: function(){ this.foo = 1; },
  getFoo: function(){ return this.foo; },
  setFoo: function(x){ this.foo = x; return this.getFoo(); }
});

// 混入 / 覆寫
var Alien = SuperHuman.extend({
  beam: function(){ this.supr(); }
});
Spazoid.implement({ beam: function(){ this.supr(); this.jets(); } });

原始碼要點

klass 的設計目標很明確:盡量模仿傳統語言的繼承語法,讓子類建構子自動呼叫父類建構子,並可用 this.supr() 明確呼叫父類同名方法。關鍵在於這個正則判斷:

var fnTest = /xyz/.test(function(){xyz;}) ? /\bsupr\b/ : /.*/;

它用來確認當前環境能否正確解析函式內容。若方法體中出現 supr 字樣,該方法會被 wrap 起來:暫時把 this.supr 指向父類同名方法,執行後再還原,因此回傳值與副作用都與原方法一致。建構子則較為靈活:顯式宣告 initialize 時以它為建構子,否則若傳入的是 function 就以之為建構子,兩者皆無時沿用父類建構子。

三、以 Object.create 手寫簡易版

思路很單純:利用 ES5 的 Object.create 做原型式繼承,在不支援的環境中平移退化。

var Class = (function(){
  var inherits = function(ctor, superCtor){
    ctor.super_ = superCtor;                 // 顯式指向父類
    if (Object.create){
      ctor.prototype = Object.create(superCtor.prototype, {
        constructor: { value: ctor, enumerable: false, writable: true, configurable: true }
      });
    } else {                                 // 無 Object.create 時的退化方案
      function F(){};
      F.prototype = superCtor.prototype;
      ctor.prototype = new F();
      ctor.prototype.constructor = ctor;
    }
  };
  return function(){
    var subClazz = arguments[arguments.length - 1] || function(){};
    var fn = (subClazz.initialize == null) ? function(){} : subClazz.initialize;
    for (var i = 0; i < arguments.length - 1; i++) inherits(fn, arguments[i]);
    for (var prop in subClazz){
      if (prop == "initialize") continue;
      fn.prototype[prop] = subClazz[prop];
    }
    return fn;
  };
})();

var Cat = Class({
  initialize: function(name){ this.name = name; },
  eat: function(){ alert(this.name + " is eating fish."); }
});

var BlackCat = Class(Cat, {
  initialize: function(name, age){
    BlackCat.super_.call(this, name);
    this.age = age;
  },
  eat: function(){ alert(this.name + "(" + this.age + ") is eating dog."); }
});

var cat = new BlackCat("John", 24);
alert(cat instanceof Cat);            // true
alert(cat.constructor === BlackCat);  // true

四、MooTools 的 Class

var Cat = new Class({
  initialize: function(name){ this.name = name; }
});
new Cat('Micia');

// Extends 繼承
var Animal = new Class({ initialize: function(age){ this.age = age; } });
var Cat = new Class({
  Extends: Animal,
  initialize: function(name, age){
    this.parent(age);          // 呼叫父類 initialize
    this.name = name;
  }
});

// Implements 混入
var Cat2 = new Class({
  Implements: Animal,
  setName: function(name){ this.name = name }
});

五、悟透 JavaScript:語法甘露風格

這個版本多了一個 New 函式,把「定義類別」與「建立實例」都優雅地封裝起來,形成一個完整的整體;另一個特色是所有類別都基於字面量而非函式。

// 建立類別
var Person = Class(object, {
  Create: function(name, age){
    this.name = name;
    this.age  = age;
  },
  SayHello: function(){
    alert("Hello, I'm " + this.name + ", " + this.age + " years old.");
  }
});
var BillGates = New(Person, ["Bill Gates", 53]);
BillGates.SayHello();

// 繼承
var Employee = Class(Person, {
  Create: function(name, age, salary){
    Person.Create.call(this, name, age);   // 呼叫基底類建構子
    this.salary = salary;
  },
  ShowMeTheMoney: function(){ alert(this.name + " $" + this.salary); }
});

// 原始碼
function Class(aBaseClass, aClassDefine){
  function class_(){
    this.Type = aBaseClass;                  // 約定 Type 屬性指向被繼承的類
    for (var member in aClassDefine)
      this[member] = aClassDefine[member];
  }
  class_.prototype = aBaseClass;
  return new class_();
}
function New(aClass, aParams){
  function new_(){
    this.Type = aClass;
    if (aClass.Create) aClass.Create.apply(this, aParams);  // 約定建構子名為 Create
  }
  new_.prototype = aClass;
  return new new_();
}

結語

看完這五種實作會發現,儘管語法糖的形式各異,底層思路高度一致:基於原型的繼承,加上對新方法的循環拷貝。差別只在於語法風格偏好——是要 klass 那種貼近傳統語言的 this.supr(),還是 my-class 的 Super.call(),或者最樸素的 super_.call()。

理解這些機制之後,自己動手寫一個專案專屬的封裝層並不困難。而若是今天開新專案,更值得考慮的是直接用 ES6 的 class 語法或 Object.assign 搭配 ES Module——這些原生方案已經把上述所有手工封裝都標準化了。

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