JavaScript 的入門門檻很低,一個從沒寫過它的人,幾小時內也能弄出一段堪用的小程式。但若因此認為它是門簡單的語言,那就大錯特錯了——想寫出高效能的程式碼,需要的是與撰寫 Java、C++ 同等的素養。一位 Java 工程師未必寫得出好的 JavaScript,但相對於毫無物件導向經驗的人,他確實更容易寫好。
JavaScript 的「簡單」源自它極強的包容性:宣告時不必指定型別,型別也能任意轉換;它支援物件導向,卻沒有 class 這個關鍵字。它崇尚自由,卻 also 要求嚴謹。
JavaScript 的物件導向與 Java、C++ 最大的差異在於繼承方式:它基於原型(prototype)鏈,所有物件最終都追溯到 Object。本文不打算比較各家繼承模型的優劣,而是聚焦在一個實務問題:如何封裝 class,以便更好地管理與維護基礎程式碼、減少重複、並走向模組化。以下整理五個在 GitHub 上評價不錯的方案。
專案位址: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)。
專案位址: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 就以之為建構子,兩者皆無時沿用父類建構子。
思路很單純:利用 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
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 }
});
這個版本多了一個 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——這些原生方案已經把上述所有手工封裝都標準化了。