前陣子讀到別人寫的一套 JS 類庫,對原型與繼承又起了興致。這塊看過好幾次,但總有一種說不上來的模糊感,趁著空檔重新梳理一遍,把理解記錄下來。
instanceof 是二元運算子,寫成 instanceA instanceof A,回傳布林值。它的實質判斷是:
A.prototype === instanceA.__proto__
function f2() {
var f = function () {};
var test = new f();
console.log(test instanceof f); // true
console.log((f.prototype === test.__proto__)); // true
}
兩行都印 true,說明 test 的 __proto__ 確實指向 f 的 prototype。
JavaScript 中一切皆物件,可分為函數物件與普通物件。
// 函數物件
var f = function () {};
var f2 = new Function('str', 'console.log(str)');
function f3() {}
// 普通物件
var o = new Object();
var o2 = {};
var o3 = new f();
兩者的區別:凡是用 new Function() 產生的都是函數物件,而 f 與 f3 這兩種宣告方式,最終底層也是走 new Function()。
更實用的判斷依據是:prototype 屬性只有函數物件才有,普通物件沒有。
var f = function () {};
var o = new Object();
console.log(f.prototype); // Object {}
console.log(o.prototype); // undefined
所有物件都有一個 __proto__,指向建立它的函數的 prototype。這種一層接一層的關係就是原型鏈。

var person = function () {};
var person1 = new person();
__proto__ 指向 person.prototype。person.prototype 本身是個物件,也有 __proto__,指向 Object.prototype。Object.prototype 的 __proto__ 則是 null,鏈到此終止。屬性查詢就是沿著這條鏈往上走,這也解釋了為什麼自訂物件都能用 toString()——方法來自鏈末端的 Object.prototype。
先定義一個函數物件:
var person = function () {};
它是物件,所以可以加屬性:
person.name1 = 'js'; console.log(person.name1); // js
但建立實例之後:
var person = function () {};
person.name1 = 122;
console.log(person.name1); // 122
var person1 = new person();
console.log(person1.name1); // undefined
person1 拿不到 name1。原因是 person.name1 掛在函數物件自己身上,而實例的原型鏈走的是 person.prototype,兩條路不相交。
要讓所有實例都能存取,就必須掛到 prototype 上:
var person = function () {};
person.prototype.name1 = '12';
var person1 = new person();
console.log(person1.name1); // 12
掛在 prototype 上的屬性,會成為所有實例的「共享屬性」。
共享意味著:如果 prototype 上的屬性是「物件或陣列」這種參考型別,所有實例改動的都會是同一份資料。
function Bag() {}
Bag.prototype.items = [];
var a = new Bag();
var b = new Bag();
a.items.push('x');
console.log(b.items); // ['x'] —— 被連帶影響了
所以規則是:基元型別的常數放 prototype,每個實例各自不同的狀態放在建構式裡用 this 定義。這也是為什麼「组合式繼承」一定要用父類建構式呼叫來複製實例屬性,而不能只靠原型鏈。