JavaScript 裡的各種引用關係又多又雜。作用域鏈是單向鏈式結構,還算清晰;this 的調用關係稍複雜;而原型部分,本質上就是 prototype、__proto__ 和 constructor 三者之間的三角關係。先用一張圖開宗明義,再逐層拆解。

上圖看似複雜,其實來源只是兩行代碼:
function Foo() {};
var f1 = new Foo;
構造函數:用來初始化新對象的函數。此處 Foo() 就是構造函數。
實例對象:由構造函數配合 new 創建的對象。一個構造函數可以造出多個實例:
function Foo() {};
var f1 = new Foo;
var f2 = new Foo;
console.log(f1 === f2); // false
原型對象與 prototype:構造函數有一個 prototype 屬性,指向它的原型對象。同一構造函數造出的實例共享同一個原型對象,繼承也常用它來實現。
function Foo() {};
Foo.prototype.a = 1;
var f1 = new Foo;
var f2 = new Foo;
console.log(Foo.prototype.a); // 1
console.log(f1.a); // 1
console.log(f2.a); // 1
constructor:原型對象有一個 constructor 屬性,指回對應的構造函數。
function Foo() {};
console.log(Foo.prototype.constructor === Foo); // true
由於實例可以繼承原型上的屬性,實例也能拿到 constructor:
function Foo() {};
var f1 = new Foo;
console.log(f1.constructor === Foo); // true
__proto__:實例對象通過這個內部屬性指向自己的原型對象。
function Foo() {};
var f1 = new Foo;
console.log(f1.__proto__ === Foo.prototype); // true
第一部分:Foo 與 f1

f1 由 new Foo() 創建。構造函數 Foo 的 prototype 指向原型對象 Foo.prototype,而 f1 也通過 __proto__ 指向同一個對象。
function Foo() {};
var f1 = new Foo;
console.log(f1.__proto__ === Foo.prototype); // true
f1 自身並沒有 constructor 屬性,它是從原型上繼承來的:
function Foo() {};
var f1 = new Foo;
console.log(Foo.prototype.constructor === Foo); // true
console.log(f1.constructor === Foo); // true
console.log(f1.hasOwnProperty('constructor')); // false,可見是繼承而來

第二部分:Object

Foo.prototype 是 f1 的原型對象,但它本身也是一個對象。任何對象都可以看成 new Object() 的結果,所以 Foo.prototype 的構造函數是 Object,原型對象是 Object.prototype;反過來,Object 的 prototype 指向 Object.prototype,Foo.prototype.__proto__ 也指向它。
function Foo() {};
var f1 = new Foo;
console.log(Foo.prototype.__proto__ === Object.prototype); // true
而 Foo.prototype 自己有一個 constructor 屬性,會覆蓋從 Object.prototype 繼承的同名屬性:
function Foo() {};
var f1 = new Foo;
console.log(Foo.prototype.constructor === Foo); // true
console.log(Object.prototype.constructor === Object); // true
console.log(Foo.prototype.hasOwnProperty('constructor')); // true,是自身屬性

那麼 Object.prototype 作為實例對象時,它的原型是什麼?答案是 null——原型鏈到此終止。這大概也是 typeof null 返回 'object' 的其中一個解釋。
console.log(Object.prototype.__proto__ === null); // true
第三部分:Function

函數也是對象,只是多了可調用的能力。任何函數都可以看成 new Function() 的結果。所以函數 Foo 作為實例時,構造函數是 Function,原型對象是 Function.prototype;Object 作為函數也是同理。
function Foo() {};
var f1 = new Foo;
console.log(Foo.__proto__ === Function.prototype); // true
console.log(Object.__proto__ === Function.prototype); // true
Function.prototype 的 constructor 指向 Function;而 Foo 和 Object 自身都沒有 constructor,需要從原型繼承:
function Foo() {};
console.log(Function.prototype.constructor === Function); // true
console.log(Foo.constructor === Function); // true
console.log(Foo.hasOwnProperty('constructor')); // false
console.log(Object.constructor === Function); // true
console.log(Object.hasOwnProperty('constructor')); // false
既然所有函數都是 Function 的實例,那麼 Function 自己呢?它可以看作自身 new 的結果,因此構造函數是 Function,原型對象是 Function.prototype:
console.log(Function.__proto__ === Function.prototype); // true console.log(Function.prototype.constructor === Function); // true
而 Function.prototype 作為對象,其原型同樣是 Object.prototype:
console.log(Function.prototype.__proto__ === Object.prototype); // true console.log(Object.prototype.__proto__ === null); // true
【1】函數(包括 Function 本身)都是 new Function 的結果,作為實例時構造函數是 Function,原型對象是 Function.prototype。
【2】對象(函數也是對象)都是 new Object 的結果,作為實例時構造函數是 Object,原型對象是 Object.prototype。
【3】Object.prototype 的原型是 null,這裡就是原型鏈的盡頭。
記住這三條,再回頭看那張圖,所有箭頭的來龍去脈都能對上號。