DIV CSS 佈局教程網

JavaScript 繼承機制完整解析:從原型到深拷貝
編輯:JavaScript綜合知識     

先澄清一個常見誤會:Java 與 JavaScript 的關係,就像雷鋒與雷峰塔的關係。JavaScript 原名 Mocha,後來叫 LiveScript,創造者是 Brendan Eich。

從歷史談起

1994 年,網景公司(Netscape)推出第一個較成熟的瀏覽器 Navigator 0.9,引起轟動。但它只能用來瀏覽,不具備與訪客互動的能力——使用者提交空白表單時,瀏覽器無從判斷,只能把資料送到伺服器再由伺服器回傳錯誤,效率低落。

因此,開發一種用戶端腳本語言變得必要,任務落到工程師 Brendan Eich 身上。他認為不必設計得太複雜,能處理表單驗證這類簡單操作就夠了。1994 年正是物件導向程式設計興盛的年代,C++ 最受歡迎,Java 1.0 也將在次年推出。受此影響,他想把 JavaScript 的所有資料型別都看作物件——但這帶來一個難題:要不要設計「繼承」機制?

一、new 關鍵字與構造函式

處理表單驗證這樣的功能,顯然不需要繼承。但既然一切都是物件,就需要某種方式把所有物件聯繫起來。最後 Eich 還是設計了繼承,只是他沒有引入「類別」(class)的概念——一旦有了 class,JavaScript 就成為完整的物件導向語言,這太正式,也偏離了設計初衷,還會提高入門門檻。

參照 C++ 與 Java 都以 new 產生實例:

ClassName *object = new ClassName(param);   // C++
Foo foo = new Foo();                        // Java

Eich 也把 new 引入 JavaScript,但因為沒有「類別」,new 後面跟的是「構造函式」而非類別:

function WD(skill) {
  this.skill = skill;
}

var WD1 = new WD('html');
console.log(WD1.skill);   // html

構造函式中的 this 代表新建立的實例物件。

二、prototype 的由來

用 new 產生的實例之間無法共享屬性與方法:

function WD(skill) {
  this.skill = skill;
  this.sex = '男';
}

var WD1 = new WD('html');
var WD2 = new WD('css');

WD1.skill = 'Javascript';
console.log(WD2.skill);   // "css",不受影響

每個實例都有自己的屬性副本,不但無法共享資料,也是資源浪費。為了解決這件事,Eich 為構造函式加上 prototype 屬性。它包含一個物件,所有需要共享的屬性與方法放在其中;不需要共享的仍留在構造函式內:

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);   // 男

WD.prototype.sex = '女';
console.log(WD1.sex);   // 女
console.log(WD2.sex);   // 女

由於所有實例共享同一個 prototype 物件,從外觀看來,prototype 就像實例的原型,而實例則像是「繼承」了 prototype——這正是 JavaScript 繼承機制的核心設計思想。

三、構造函式的繼承實作

現在有一個父類別與一個子類別:

function MED() {
  this.aim = "營銷體驗設計";
}

function WD(skill, sex) {
  this.skill = skill;
  this.sex = sex;
}

做法一: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);   // "營銷體驗設計"

缺點是只能繼承實例屬性,無法繼承原型上的方法。

做法二:prototype 模式

讓子類別的 prototype 指向父類別的一個實例:

WD.prototype = new MED();
WD.prototype.constructor = WD;   // 關鍵:補回 constructor

var WD1 = new WD("Html", "男");
console.log(WD1.aim);   // 營銷體驗設計

第二行不是可有可無的。任何 prototype 物件都有一個 constructor 屬性指回它的構造函式。前一行等於完全替換了 prototype 物件,新的 prototype 沒有 constructor,必須手動補上,否則後續的「繼承鏈」會出問題。這是一個重點:只要替換了 prototype,下一步就必須補 constructor。

做法三:直接繼承 prototype

既然不變的屬性都可以寫在 prototype 上,也可以讓子類別跳過父類別的構造函式,直接繼承其 prototype:

function MED() {}
MED.prototype.skill = "MED";

WD.prototype = MED.prototype;
WD.prototype.constructor = WD;

var WD1 = new WD("Html", "男");
console.log(WD1.skill);   // MED

優點是效率高、省記憶體(不必建立 MED 的實例)。缺點是兩者的 prototype 指向同一個物件,任何對 WD.prototype 的修改都會反映到 MED.prototype。上面第二行就有問題——它連 MED.prototype.constructor 都改了:

console.log(MED.prototype.constructor);   // WD,已經被汙染

做法四:以空物件作為中介

為避開上述缺點,引入一個空函式當跳板:

var F = function () {};
F.prototype = MED.prototype;
WD.prototype = new F();
WD.prototype.constructor = WD;

console.log(MED.prototype.constructor);   // MED,未被汙染

F 幾乎不佔記憶體,而修改 WD.prototype 不再影響 MED.prototype。

做法五:封裝成 extend 函式

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 函式庫實作繼承的方式。

做法六:拷貝繼承

既然子物件會擁有父物件的屬性與方法,直接拷貝也能達到效果:

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

四、非構造函式的繼承

如果兩者都是普通物件而非構造函式,又該如何?

var MED = { aim: '營銷體驗設計' };
var WD  = { skill: 'html' };

object() 方法

JSON 格式的發明者 Douglas Crockford 提出一個 object() 函式:

function object(o) {
  function F() {}
  F.prototype = o;
  return new F();
}

var WD = object(MED);
WD.skill = 'html';
console.log(WD.aim);   // 營銷體驗設計

它做的事只有一件:把子物件的 prototype 指向父物件,讓兩者連成一條原型鏈。ES5 之後這個模式已被標準化為 Object.create()。

淺拷貝

另一條思路是把父物件的屬性全部複製給子物件:

function LightCopy(p) {
  var c = {};
  for (var i in p) {
    c[i] = p[i];
  }
  return c;
}

var WD = LightCopy(MED);
WD.aim = '前端開發';

問題是:若屬性值是陣列或另一個物件,複製到的只是一個記憶體位址而非真正的複本,父物件可能被竄改:

MED.skills = ['html', 'css', 'Javascript'];
var WD = LightCopy(MED);

WD.skills.push('teamwork');

console.log(WD.skills);    // ['html','css','Javascript','teamwork']
console.log(MED.skills);   // 也被改了!

因此 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 使用的就是這種繼承方式。

現代寫法

ES6 的 class 語法本質上仍是原型繼承,只是語法糖。今天要實作繼承,直接用 class 與 extends 即可,Object.create 則用於「以某物件為原型建立新物件」的情境:

class MED {
  constructor() { this.aim = '營銷體驗設計'; }
}

class WD extends MED {
  constructor(skill, sex) {
    super();
    this.skill = skill;
    this.sex = sex;
  }
}

而深拷貝在現代有兩個標準選擇:需要複製資料結構時用 structuredClone(),需要複製成 JSON 相容資料時用 JSON.parse(JSON.stringify(obj))(但此法會丟失 undefined、函式、Date 會變字串)。理解上述原型鏈與深淺拷貝的原理,才能知道這些工具背後在做什麼,也才能在遇到邊界情況時判斷該用哪一種。

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