對於熟悉基於類的面向對象語言(Java 或 C++)的開發者來說,JavaScript 的語法比較怪異,因為它是一門動態語言,而且沒有類的概念(ES6 新增了 class 關鍵字,但那只是語法糖,JavaScript 仍舊基於原型)。
涉及繼承時,JavaScript 只有一種結構:對象。每個對象都有一個指向其原型(prototype)對象的內部鏈接,這個原型又有自己的原型,直到某個對象的原型為 null 為止(不再有原型指向),組成這條鏈的最後一環。這種一級一級的鏈結構稱為原型鏈(prototype chain)。
雖然原型繼承常被視為 JavaScript 的一個弱點,但事實上,原型繼承模型比經典的繼承模型更強大。
JavaScript 對象是動態的屬性「包」,並有一個指向原型對象的鏈。當訪問一個對象的屬性時,不僅在該對象上搜尋,還會搜尋它的原型、原型的原型,層層向上,直到找到匹配的屬性或到達原型鏈末尾。
根據 ECMAScript 標準,someObject.[[Prototype]] 用於指派 someObject 的原型,等同於 JS 的 __proto__ 屬性(現已棄用)。從 ES6 開始,[[Prototype]] 可用 Object.getPrototypeOf() 和 Object.setPrototypeOf() 訪問。
下面的代碼演示訪問屬性時發生的行為:
// 假定對象 o 自身屬性有 a 和 b:{a: 1, b: 2}
// 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 是 o 的自身屬性
console.log(o.b); // 2,b 是自身屬性,原型上的 b 不會被訪問(屬性遮蔽)
console.log(o.c); // 4,c 不是自身屬性,在原型上找到
console.log(o.d); // undefined,一路找到 null 都沒有 d
JavaScript 沒有其他基於類的語言所定義的「方法」。任何函數都可以添加到對象上作為屬性,函數的繼承與其他屬性繼承沒有差別,包括「屬性遮蔽」(相當於其他語言的方法重寫)。當繼承的函數被調用時,this 指向的是當前繼承的對象,而不是函數所在的原型對象。
var o = { a: 2, m: function(){ return this.a + 1; } };
console.log(o.m()); // 3,調用 o.m 時 this 指向 o
var p = Object.create(o); // p.[[Prototype]] 是 o
p.a = 12; // 創建 p 的自身屬性 a
console.log(p.m()); // 13,this 指向 p,this.a 即 p.a
var o = {a: 1};
// o ---> Object.prototype ---> null
var a = ["yo", "whadup", "?"];
// a ---> Array.prototype ---> Object.prototype ---> null
function f(){ return 2; }
// f ---> Function.prototype ---> Object.prototype ---> null
在 JavaScript 中,構造器其實就是一個普通函數,當用 new 操作符作用時,就稱為構造方法。
function Graph() {
this.vertexes = [];
this.edges = [];
}
Graph.prototype = {
addVertex: function(v){
this.vertexes.push(v);
}
};
var g = new Graph();
// 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,包括 class、constructor、static、extends 和 super。熟悉基於類語言的開發者會感到熟悉,但它們並不一樣,JavaScript 仍然是基於原型的。
"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,它破壞了原型鏈的密封性。我們擴展內置對象原型的唯一理由,是引入新引擎的某些新特性,比如 Array.forEach。
B 將繼承自 A:
function A(a){
this.varA = a;
}
A.prototype = {
varA: null,
doSomething: function(){
// ...
}
}
function B(a, b){
A.call(this, a);
this.varB = b;
}
B.prototype = Object.create(A.prototype, {
varB: {
value: null,
enumerable: true,
configurable: true,
writable: true
},
doSomething: {
value: function(){
// 覆蓋並調用父類方法
A.prototype.doSomething.apply(this, arguments);
// ...
},
enumerable: true,
configurable: true,
writable: true
}
});
B.prototype.constructor = B;
var b = new B();
b.doSomething();
最重要的兩點:類型定義在 .prototype 中;用 Object.create() 來繼承。
對從 Java 或 C++ 轉過來的開發者來說,JavaScript 讓人困惑,因為它全是動態的、運行時的,且不存在類,一切都是實例(對象)。即使我們模擬出的「類」,也只是一個函數對象。
我們的函數 A 有一個特殊屬性叫做原型,這個屬性與 new 運算符一起工作。對原型對象的引用會復制到新實例內部的 [[Prototype]] 屬性。當你寫 var a1 = new A() 時,JavaScript 會設置 a1.[[Prototype]] = A.prototype。然後訪問實例屬性時,先檢查是否直接存在於該對象中,若沒有則在 [[Prototype]] 中查找。也就是說,你在原型中定義的元素將被所有實例共享,甚至可以稍後修改原型並影響所有現存實例。
簡而言之,prototype 是用於類型的,而 Object.getPrototypeOf() 是用於實例的,兩者功能一致。[[Prototype]] 看起來像遞歸引用:a1.doSomething、Object.getPrototypeOf(a1).doSomething、Object.getPrototypeOf(Object.getPrototypeOf(a1)).doSomething……直到找到屬性或 Object.getPrototypeOf 返回 null。
因此,當你執行:
var o = new Foo();
JavaScript 實際上執行的是:
var o = new Object(); o.[[Prototype]] = Foo.prototype; Foo.call(o);
而當你執行 o.someProp; 時,它會檢查是否存在 someProp,沒有就查 Object.getPrototypeOf(o).someProp,仍沒有就繼續往上,直到找到或返回 null。
在用原型繼承編寫複雜代碼前,理解原型繼承模型十分重要。同時要清楚代碼中原型鏈的長度,必要時結束原型鏈以避免性能問題。此外,除非為了兼容新特性,否則永遠不要擴展原生的對象原型。