DIV CSS 佈局教程網

JavaScript 教程:全面重溫 JavaScript 繼承機制
編輯:關於JavaScript     

前陣子團隊內部辦了幾場很不錯的分享,這裡整理一下西風師傅講的繼承機制,並適度加入口語化的說明,留作日後參考。

一、先講個故事

先澄清一件事: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 頗為相似。但他隨即遇到難題:到底要不要設計「繼承」機制?

二、繼承的演變

1. 採用 new 關鍵字生成實例

處理表單驗證這樣的簡單功能,顯然不需要「繼承」。可一旦 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,代表的是新創建的實例對象。

2. new 出來對象的缺陷

用構造函數生成實例,無法共享屬性和方法。比如在 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 影響

每個實例都保有一份自己的屬性和方法副本,這不僅無法共享數據,也是資源的浪費。

3. 引入 prototype 屬性

為了實現屬性和方法的共享,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 呢?

1. apply 綁定構造函數實現

最簡單的方法,是用 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); // "營銷體驗設計"

2. prototype 模式實現

常見做法是使用 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;)。

3. 從 prototype 直接繼承實現

由於 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

4. 利用一個空對象作為中介來實現

由於「直接繼承 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

5. 封裝成 prototype 模式的函數

把上面的方法封裝成一個函數,方便調用:

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 庫實現繼承的方法。

6. 拷貝繼承實現

既然子對象會擁有父對象的屬性和方法,那麼直接「拷貝」也能達到效果。先把 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,也就是生成一個「營銷體驗設計的前端開發」對象?注意這兩個都是普通對象,不是構造函數,無法用構造函數方法實現繼承。

1. object() 方法

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); // 營銷體驗設計

2. 淺拷貝

除了「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 實現繼承的方式。

3. 深拷貝

「深拷貝」能實現真正意義上的數組和對象拷貝,做法不難——只要遞歸調用「淺拷貝」即可:

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 庫採用的正是这种繼承方法。

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