DIV CSS 佈局教程網

JavaScript 繼承與原型鏈深入解析
編輯:JavaScript基礎知識     

對於熟悉基於類的面向對象語言(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

使用 Object.create 創建對象

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

使用 class 關鍵字

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() 來繼承。

prototype 和 Object.getPrototypeOf

對從 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。

結論

在用原型繼承編寫複雜代碼前,理解原型繼承模型十分重要。同時要清楚代碼中原型鏈的長度,必要時結束原型鏈以避免性能問題。此外,除非為了兼容新特性,否則永遠不要擴展原生的對象原型。

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