DIV CSS 佈局教程網

JavaScript 原型 prototype 完全解析
編輯:JavaScript基礎知識     

想真正讀懂 JavaScript 的 prototype,得先立住三個前提:

  1. JavaScript 裡一切都是對象;
  2. 所有對象都由 Object 衍生而來,原型鏈的終點指向 Object.prototype;
  3. 構造函數與實例之間存在微妙的對應關係。
// ["constructor", "toString", "toLocaleString", "valueOf", "hasOwnProperty", "isPrototypeOf",
//  "propertyIsEnumerable", "__defineGetter__", "__lookupGetter__", "__defineSetter__",
//  "__lookupSetter__"]
console.log(Object.getOwnPropertyNames(Object.prototype));

構造函數通過定義 prototype 來約定其實例的規格,再用 new 構造出實例,二者的共同職責就是生產對象。而構造函數(方法)本身又是 Function 的實例,因此也能查到它的 __proto__。

像 Object、function F() {} 這樣的是構造函數,一個來自原生 API,一個是自定义的;new Object()、new F() 這樣的是實例。實例只能通過查看 __proto__ 得知自己是基於哪個 prototype 造出來的,而無法再重新定義實例的 prototype 去創造「實例的實例」。

動手觀察才看得明白

// 先看看構造函數到底是什麼
function Empty() {}
console.log(Function.prototype, Function.__proto__);

function Empty2() {}
console.log(Object.prototype, Object.__proto__);

function F() {}
console.log(F.prototype, F.__proto__);

輸出格式可以概括為「構造函數名 + 原型」。Object {} 表示構造函數名叫 Object,原型是一個空對象;同理 F {} 就是構造函數 F 的原型也是一個空對象。

從構造函數到實例

var o = new Object();
// var o = {};
console.log(o.prototype, o.__proto__); // undefined Object {}

function F() {}
var i = new F();
console.log(i.prototype, i.__proto__); // undefined F {}

注意實例上的 prototype 是 undefined——prototype 是構造函數才有的屬性。往 F 的原型上加點東西再看看:

function F() {}
F.prototype.a = function() {};
var i = new F();
console.log(i.prototype, i.__proto__); // undefined F {a: function}

可以清楚看到 i 由 F 構造而來,原型是 {a: function},也就是原本的空對象多了一個 a 方法。

整體覆蓋 prototype 會踩的坑

function F() {}
F.prototype = { a: function() {} };
var i = new F();
console.log(i.prototype, i.__proto__); // undefined Object {a: function}

i 竟然變成 Object 構造出來的?原因是我們把 F 的 prototype 整個換掉了,等於把原型指定為對象 {a: function},原本 prototype 上的 constructor 信息就此丟失,變成了新對象自帶的 constructor。而 {a: function} 相當於:

var o = {a: function() {}} // 相當於 new 了一個 Object

它的 constructor 自然是 Object。修正方式是把 constructor 補回去:

function F() {}
F.prototype = { a: function() {} }
// 重新指定正確的構造函數
F.prototype.constructor = F;
var i = new F();
console.log(i.prototype, i.__proto__);

原型鏈

原型鏈可以理解為面向對象語言中的繼承鏈:一層一層往上找,最終抵達 Object.prototype。

關鍵要記住兩件事:JS 中所有東西都是對象;任何一個對象都有一個原型。下面用代碼驗證:

Object                              // 函數是 Function 的實例
Object.__proto__ == Function.prototype   // true
Function.prototype.__proto__ == Object.prototype  // true
Object.prototype.__proto__ == null       // true,原型鏈的頂端

Function.__proto__ == Function.prototype  // true

function A() {}
A.__proto__ == Function.prototype     // 任何函數都是 Function 的實例

var a = new A()
a.__proto__ == A.prototype            // 實例 a 由 A 構造,原型由 A.prototype 定義
A.prototype.__proto__ == Object.prototype  // 普通對象都是 Object 的實例

prototype 與 __proto__ 的分工

每個對象都有一個 __proto__,指向它的原型;每個函數又都有一個 prototype。這個 prototype 是幹什麼的?用構造函數創建對象來看:

function Foo(){};
var foo = new Foo();
console.log(foo.__proto__);

foo 的 __proto__ 指向什麼?

是一個帶 constructor 屬性的對象。把 Foo.prototype 打印出來對比一下就清楚了:

function Foo(){};
var foo = new Foo();
console.log(foo.__proto__);
console.log(Foo.prototype);
console.log(foo.__proto__ === Foo.prototype); // true

也就是說,new 出來的對象,其 __proto__ 指向構造函數的 prototype:

foo.__proto__ --> Foo.prototype

這樣設計的意義在於:JS 世界裡對象不是按類(模具)創建的,而是從另一個對象(原型)衍生而來的。執行 new 時,新對象的 __proto__ 需要指向一個原型對象——它不能指向 Foo 函數本身,雖然函數也是對象,但 Foo 裡有大量邏輯代碼,讓 foo 去繼承這些毫無意義,它真正要繼承的是原型對象上的屬性。

所以每個函數都會自動生成一個 prototype 對象,由該函數 new 出來的對象,__proto__ 就指向它。

三條事實收尾

1. 每個對象都有一個 __proto__ 屬性。JS 沒有類的概念,對象從另一個對象衍生而來,因此需要一個指針記錄自己的原型。

2. 每個函數都有一個 prototype 屬性。構造函數之所以叫構造函數,是因為它負責造對象;造出來的新對象總得有個原型可指向,於是函數自帶一個 prototype 指向該原型對象。

3. 函數也是對象。apply()、call() 這些通用方法從哪來?因為函數也是由構造函數(Function)構造出來的對象,每個函數都有 __proto__ 指向 Function.prototype,通用方法就存放在那裡。

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