對寫過 Java 或 C++ 的人來說,JavaScript 的物件導向語法確實有點怪。原因很簡單:JavaScript 是動態語言,本身並沒有 class 的概念(ES6 雖然補上了 class 關鍵字,但那只是語法糖,底層依然是原型導向)。
JavaScript 裡只有一種繼承結構,就是「物件」。每個物件都有一條內部連結指向它的原型物件,原型又有自己的原型,一路往上直到某個物件的原型為 null 才停止,這一長串串起來就是所謂的原型鏈(prototype chain)。
很多人把原型繼承當成 JavaScript 的弱點,但實際上原型模型比傳統的類別繼承更靈活——想在原型之上模擬出傳統繼承,反而相當容易。
JavaScript 物件本質上就是一個動態的屬性包。讀取某個屬性時,引擎不只找物件本身,還會沿著原型鏈一層層往上找,直到找到同名屬性或抵達鏈尾。
// 假設物件 o 自身有 a 與 b:{a: 1, b: 2} // o 的原型 o.[[Prototype]] 有 b 與 c:{b: 3, c: 4} // 再上一層 o.[[Prototype]].[[Prototype]] 為 null,即鏈尾 // 完整原型鏈: // {a:1, b:2} ---> {b:3, c:4} ---> null console.log(o.a); // 1,a 是自身屬性 console.log(o.b); // 2,b 是自身屬性;原型上的 b 不會被讀到,這叫「屬性遮蔽」(property shadowing) console.log(o.c); // 4,自身沒有,往原型找到 console.log(o.d); // undefined,一路找到 null 都沒找到
要新增自身屬性,直接賦值即可。唯一的例外是當繼承而來的屬性設有 getter 或 setter 時,賦值行為會走那組存取器。
JavaScript 並沒有其他語言那種嚴格定義的「方法」,任何函式都可以掛到物件上當屬性,繼承方式與一般屬性完全相同,也同樣會發生遮蔽(等同其他語言的方法覆寫)。
重點在 this:呼叫繼承而來的函式時,this 指向的是「目前呼叫它的物件」,而不是函式原本所屬的原型物件。
var o = { a: 2, m: function(){ return this.a + 1; } }; console.log(o.m()); // 3,this 指向 o var p = Object.create(o); // p 的原型是 o p.a = 12; // 建立 p 的自身屬性 a console.log(p.m()); // 13,呼叫 p.m 時 this 指向 p,因此 this.a 等於 p.a
var o = {a: 1}; // 原型鏈:o ---> Object.prototype ---> null // 所以能用 o.hasOwnProperty('a'),hasOwnProperty 來自 Object.prototype var a = ["yo", "whadup", "?"]; // 陣列原型鏈:a ---> Array.prototype ---> Object.prototype ---> null // indexOf、forEach 等方法都繼承自 Array.prototype function f(){ return 2; } // 函式原型鏈:f ---> Function.prototype ---> Object.prototype ---> null // call、bind 等方法繼承自 Function.prototype
JavaScript 的建構函式其實就是普通函式,只是被 new 運算子呼叫時才具備建構意義。
function Graph() { this.vertexes = []; this.edges = []; } Graph.prototype = { addVertex: function(v){ this.vertexes.push(v); } }; var g = new Graph(); // g 的自身屬性有 vertices 與 edges,g.[[Prototype]] 指向 Graph.prototype
ES5 提供的 Object.create() 可以指定原型來建立新物件:
var a = {a: 1}; // a ---> Object.prototype ---> null var b = Object.create(a); // b ---> a ---> Object.prototype ---> null console.log(b.a); // 1,繼承而來 var c = Object.create(b); // c ---> b ---> a ---> Object.prototype ---> null var d = Object.create(null); // d ---> null console.log(d.hasOwnProperty); // undefined,d 沒有繼承 Object.prototype
ES6 引入了 class、constructor、static、extends、super 等關鍵字,寫起來對熟悉類別語言的人很親切,但底層仍是原型,別被表象騙了。
"use strict"; class Polygon { constructor(height, width) { this.height = height; this.width = width; } } class Square extends Polygon { constructor(sideLength) { super(sideLength, sideLength); } get area() { return this.height * this.width; } set sideLength(newLength) { this.height = newLength; this.width = newLength; } } var square = new Square(2);
沿著原型鏈找屬性是有成本的,效能敏感時要留意。存取不存在的屬性會把整條鏈走一遍,而列舉屬性時原型鏈上所有可列舉的屬性都會被帶出來。
想確認屬性是自己身上的還是在原型鏈上,該用 hasOwnProperty。它是 JavaScript 裡唯一只檢視自身屬性、不遍歷原型鏈的方法。
另外要注意:不能只憑值是否為 undefined 來判斷屬性存不存在,屬性完全可能存在而值剛好就是 undefined。
擴充 Object.prototype 或其他內建物件原型是很常見的錯誤示範,這行為被稱為 monkey patching,會破壞原型鏈的密封性。雖然 Prototype.js 這類老框架這麼做過,但沒有正當理由去污染內建型別系統。唯一還算合理的情境,是為了補上舊引擎缺少的新特性,例如 Array.prototype.forEach。
function A(a){ this.varA = a; } // A.prototype.varA 總會被 this.varA 遮蔽, // 但仍放在原型上,一方面是文件化預設值,另一方面有助於引擎在隱藏類別中預留空間。 A.prototype = { varA : null, doSomething : function(){ // ... } } function B(a, b){ A.call(this, a); // 借用 A 的建構函式初始化 this.varA = b; } B.prototype = Object.create(A.prototype, { varB : { value: null, enumerable: true, configurable: true, writable: true }, doSomething : { value: function(){ // 覆寫 A.prototype.doSomething A.prototype.doSomething.apply(this, arguments); // 呼叫「父類」 // ... }, enumerable: true, configurable: true, writable: true } }); B.prototype.constructor = B; // 修正 constructor 指向 var b = new B(); b.doSomething();
兩個關鍵點:型別的成員定義在 .prototype 上,而繼承用 Object.create() 完成,別忘了把 constructor 指回自己。
從 Java 或 C++ 轉來的人常會困惑,因為 JavaScript 全在執行期、全是物件,連我們模擬出來的「類別」也只是函式物件。
函式 A 有個特殊屬性叫 prototype,它會與 new 運算子協同運作:建立實例時,A.prototype 的參照會被複製到新實例的內部 [[Prototype]]。也就是說 var a1 = new A() 時,JavaScript 會先設定 a1.[[Prototype]] = A.prototype,再執行函式 A 裡的 this 綁定。
之後讀取實例屬性時,引擎先看是不是自身屬性,找不到就往 [[Prototype]] 找。因此定義在原型上的成員會被所有實例共用,而且後續修改原型會即時反映到所有既有實例上。
所以 a1.doSomething 實際上就是 Object.getPrototypeOf(a1).doSomething,也就是 A.prototype.doSomething 的內容。一句話總結:prototype 是給型別用的,Object.getPrototypeOf() 是給實例用的,兩者功能一致。
[[Prototype]] 的查找本質上是遞迴的,一路 Object.getPrototypeOf(Object.getPrototypeOf(a1)) 這樣往上,直到找到屬性或回傳 null 為止。
var o = new Foo();
JavaScript 實際做的是:
var o = new Object(); o.[[Prototype]] = Foo.prototype; Foo.call(o);
而当你執行 o.someProp; 時,它會依序檢查 someProp 是否存在於 o、Object.getPrototypeOf(o)、再上一層……直到找到或遇到 null。