先澄清一個常見誤會:Java 與 JavaScript 的關係,就像雷鋒與雷峰塔的關係。JavaScript 原名 Mocha,後來叫 LiveScript,創造者是 Brendan Eich。
1994 年,網景公司(Netscape)推出第一個較成熟的瀏覽器 Navigator 0.9,引起轟動。但它只能用來瀏覽,不具備與訪客互動的能力——使用者提交空白表單時,瀏覽器無從判斷,只能把資料送到伺服器再由伺服器回傳錯誤,效率低落。
因此,開發一種用戶端腳本語言變得必要,任務落到工程師 Brendan Eich 身上。他認為不必設計得太複雜,能處理表單驗證這類簡單操作就夠了。1994 年正是物件導向程式設計興盛的年代,C++ 最受歡迎,Java 1.0 也將在次年推出。受此影響,他想把 JavaScript 的所有資料型別都看作物件——但這帶來一個難題:要不要設計「繼承」機制?
處理表單驗證這樣的功能,顯然不需要繼承。但既然一切都是物件,就需要某種方式把所有物件聯繫起來。最後 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 代表新建立的實例物件。
用 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;
}
最簡單的方式是用 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 = 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:
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。
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' };
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 會變字串)。理解上述原型鏈與深淺拷貝的原理,才能知道這些工具背後在做什麼,也才能在遇到邊界情況時判斷該用哪一種。