前陣子團隊內部辦了幾場很不錯的分享,這裡整理一下西風師傅講的繼承機制,並適度加入口語化的說明,留作日後參考。
先澄清一件事:Java 和 JavaScript 的關系,就像雷鋒和雷峰塔——名字相近,實則毫無關聯。JavaScript 原名 Mocha,後來叫過 LiveScript,創造者是現任 Mozilla 首席技術官 Brendan Eich。
1994 年,歷史上第一個較成熟的網絡瀏覽器——Navigator 0.9 誕生於網景公司(Netscape),一時轟動。但 Navigator 0.9 只能用來瀏覽,不具備與訪客互動的能力。舉例來說,使用者提交表單,若表單為空,瀏覽器無法判斷,只能把空值丟給服務器端,再由服務器返回錯誤讓使用者重填,既低效又浪費資源。
於是,走在技術革新最前沿的 Netscape,迫切需要一種實用的客戶端腳本語言來解決這類問題,任務落到了工程師 Brendan Eich 身上。他的想法很務實:不必設計得太復雜,能搞定一些簡單操作(例如判斷使用者有沒有填表單)就夠了。
1994 年恰逢面向對象編程(OOP)的全盛時期,C++ 是最流行的語言,Java 1.0 也將於次年推出,Brendan Eich 難免受其影響。他想把 JavaScript 裡的所有數據類型都視為對象,這點與 Java 頗為相似。但他隨即遇到難題:到底要不要設計「繼承」機制?
處理表單驗證這樣的簡單功能,顯然不需要「繼承」。可一旦 JavaScript 裡都是對象,就需要有辦法把對象彼此聯系起來。最終 Brendan Eich 還是設計了「繼承」,但他並沒有引入「類」(class)的概念——因為一旦有了類,JavaScript 就成了完整的面向對象語言,這既顯得太正式,也偏離了設計初衷,還會抬高初學者的門檻。
參照 C++ 和 Java 都用 new 命令生成實例:
C++:ClassName *object = new ClassName(param); Java:Foo foo = new Foo();
那麼,也可以把 new 引入 JavaScript,用來從原型對象生成一個實例對象。但沒有「類」的 JavaScript,該如何表示原型對象呢?C++ 和 Java 在使用 new 時都會調用「類」的構造函數(constructor),於是 Brendan Eich 簡化了設計:new 後面跟的是構造函數,而非類。
舉例來說,現在有一個名為 WD 的構造函數,表示前端開發(web-developer)對象的原型。
function WD(skill){ this.skill = skill; }
對這個構造函數使用 new,就會生成一個前端開發對象的實例。
var WD1 = new WD('html'); console.log(WD1.skill); // html
構造函數中的 this,代表的是新創建的實例對象。
用構造函數生成實例,無法共享屬性和方法。比如在 WD 的構造函數裡設置一個共有屬性 skill:
function WD(skill){ this.skill = skill; this.sex = '男'; }
生成兩個實例:
var WD1 = new WD('html'); var WD2 = new WD('css');
這兩個對象的 skill 屬性彼此獨立,改動其中一個不會影響另一個:
WD1.skill= 'Javascript'; console.log(WD2.skill);//"css",不受 WD1 影響
每個實例都保有一份自己的屬性和方法副本,這不僅無法共享數據,也是資源的浪費。
為了實現屬性和方法的共享,Brendan Eich 決定為構造函數設置一個 prototype 屬性。這個屬性包含一個對象(簡稱「prototype 對象」),所有需要共享的屬性和方法都放在其中;不需要共享的,則留在構造函數裡。實例一旦創建,會自動引用 prototype 對象的屬性和方法。也就是說,實例的屬性和方法分成兩種:一種是本地的,另一種是引用的。
仍用 WD 構造函數改寫:
function WD(skill){ this.skill = skill; }
WD.prototype = { sex : '男' };
var WD1 = new WD('html'); var WD2 = new WD('css');
console.log(WD1.sex); // 男
console.log(WD2.sex); // 男
此時 sex 屬性放在 prototype 對象裡,為兩個實例共享。只要修改 prototype 對象,就會同時影響兩個實例:
WD.prototype.sex = '女'; console.log(WD1.sex); // 女 console.log(WD2.sex); // 女
由於所有實例共享同一個 prototype 對象,從外界看,prototype 對象就像實例的原型,而實例則像「繼承」了 prototype 對象——這正是 JavaScript 繼承機制的設計思想。
現在有一個 MED 對象的構造函數(MED:Marketing Experience Design,營銷體驗設計):
function MED(){ this.aim = "營銷體驗設計"; }
以及 WD 對象的構造函數:
function WD(skill,sex){ this.skill = skill; this.sex = sex; }
怎樣才能讓 WD 繼承 MED 呢?
最簡單的方法,是用 call 或 apply 把父對象的構造函數綁定到子對象上,也就是在子對象構造函數裡加一行:
function WD(skill,sex){ MED.apply(this, arguments); this.skill = skill; this.sex = sex; }
var WD1 = new WD("Html","男");
console.log(WD1.aim); // "營銷體驗設計"
常見做法是使用 prototype 屬性。如果讓 WD 的 prototype 指向一個 MED 的實例,那麼所有 WD 的實例都能繼承 MED。
WD.prototype = new MED(); //把 WD 的 prototype 指向一個 MED 實例
WD.prototype.constructor = WD;
var WD1 = new WD("Html","男");
console.log(WD1.aim); // 營銷體驗設計
第一句相當於完全刪除 prototype 對象原來的值,再賦予新值。那第二句呢?任何 prototype 對象都有一個 constructor 屬性,指向它的構造函數。也就是說,WD.prototype 的 constructor 本應指向 WD。但上一步我們已刪除了原 prototype 的值,新 prototype 沒有 constructor 屬性,必須手動補上,否則後續的「繼承鏈」會出問題。
這一點很重要:只要替換了 prototype 對象(o.prototype = {};),下一步就必然要把 constructor 指回原構造函數(o.prototype.constructor = o;)。
由於 MED 中不變的屬性都可以直接寫進 MED.prototype,所以我們也能讓 WD 跳過 MED,直接繼承 MED.prototype。先改寫 MED:
function MED(){ }
MED.prototype.skill = "MED";
再把 WD 的 prototype 指向 MED 的 prototype:
WD.prototype = MED.prototype;
WD.prototype.constructor = WD;
var WD1 = new WD("Html","男");
console.log(WD1.skill); // MED
這種做法效率較高(不必執行並建立 MED 的實例)、比較省內存。缺點是 WD.prototype 和 MED.prototype 指向了同一個對象,任何對 WD.prototype 的修改都會反映到 MED.prototype。所以上面第二行其實有問題——它連 MED.prototype 的 constructor 也一起改掉了:
console.log(MED.prototype.constructor); // WD
由於「直接繼承 prototype」存在上述缺點,可以用一個空對象作為中介:
var F = function(){};
F.prototype = MED.prototype;
WD.prototype = new F();
WD.prototype.constructor = WD;
F 是空對象,幾乎不占內存。此時修改 WD 的 prototype 不會影響到 MED:
console.log(MED.prototype.constructor); // MED
把上面的方法封裝成一個函數,方便調用:
function extend(Child, Parent) {
var F = function(){};
F.prototype = Parent.prototype;
Child.prototype = new F();
Child.prototype.constructor = Child;
}
使用時:
extend(WD,MED);
var WD1 = new WD("Html","男");
console.log(WD1.aim); // 營銷體驗設計
這個 extend 函數正是 YUI 庫實現繼承的方法。
既然子對象會擁有父對象的屬性和方法,那麼直接「拷貝」也能達到效果。先把 MED 的不變屬性放到它的 prototype 上:
function MED(){}
MED.prototype.aim = "營銷體驗設計";
再寫一個函數實現屬性拷貝:
function extendCopy(Child, Parent) {
var p = Parent.prototype;
var c = Child.prototype;
for (var i in p) {
c[i] = p[i];
}
}
使用時:
extendCopy(WD, MED);
var WD1 = new WD("Html","男");
console.log(WD1.aim); // 營銷體驗設計
現在有一個普通對象 MED(營銷體驗設計):
var MED = { aim:'營銷體驗設計' }
還有一個普通對象 WD(前端開發):
var WD ={ skill:'html' }
怎樣才能讓 WD 繼承 MED,也就是生成一個「營銷體驗設計的前端開發」對象?注意這兩個都是普通對象,不是構造函數,無法用構造函數方法實現繼承。
JSON 格式的發明者 Douglas Crockford 提出了一個 object() 函數:
function object(o) {
function F() {}
F.prototype = o;
return new F();
}
這個函數只做一件事:把子對象的 prototype 指向父對象,使子父兩者聯系起來。使用時,先在父對象基礎上生成子對象:
var WD = object(MED);
再加上子對象自身的屬性:
WD.skill = 'html';
此時子對象已繼承父對象的屬性:
console.log(WD.aim); // 營銷體驗設計
除了「prototype 鏈」,還有一種思路:把父對象的屬性全部拷貝給子對象。下面的函數就在做這件事:
function LightCopy(p) {
var c = {};
for (var i in p) {
c[i] = p[i];
}
return c;
}
使用時:
var WD = LightCopy(MED); WD.aim = '前端開發';
但這種拷貝有個問題:若父對象的屬性等於數組或另一個對象,子對象拿到的其實只是一個內存地址,而非真正的拷貝,因此父對象可能被篡改。比如給 MED 加一個「技能」屬性,值為數組:
MED.skills = ['html','css','Javascript'];
var WD = LightCopy(MED);
WD.skills.push('teamwork');
結果 MED 的「技能」也被改動了:
console.log(WD.skills); // html,'Javascript','css','teamwork' console.log(MED.skills); // html,'Javascript','css','teamwork'
所以 LightCopy() 只拷貝基本類型數據,稱之為「淺拷貝」,這是早期 jQuery 實現繼承的方式。
「深拷貝」能實現真正意義上的數組和對象拷貝,做法不難——只要遞歸調用「淺拷貝」即可:
function deepCopy(p, c) {
var c = c || {};
for (var i in p) {
if (typeof p[i] === 'object') {
c[i] = (p[i].constructor === Array) ? [] : {};
deepCopy(p[i], c[i]);
} else {
c[i] = p[i];
}
}
return c;
}
使用時:
var WD = deepCopy(MED);
MED.skills = ['html','css','Javascript'];
WD.skills.push('teamwork');
這時父對象就不會受到影響了:
console.log(WD.skills); // html,'css','Javascript','teamwork' console.log(MED.skills); // html,'css','Javascript'
目前 jQuery 庫採用的正是这种繼承方法。