DIV CSS 佈局教程網

白話談原型鏈:用一則家族比喻把 JS 繼承講透
編輯:關於JavaScript     

原型鏈這東西理解起來有點繞,網上的資料又多又雜。我個人的習慣是睡不著的時候翻兩篇講原型鏈和閉包的文章,效果極好。

所以先別糾結那一堆術語,那除了把你的腦袋擰成麻花之外真的沒什麼幫助。我們換個角度,想一件跟程式無關的事:人、妖,以及人妖。

一、人是人他媽生的,妖是妖他媽生的。人和妖都是物件實例,而人他媽、妖他媽就是原型。原型本身也是物件,叫做原型物件。

二、人他媽和人他爸啪啪啪能生出一堆人寶寶,妖他媽和妖他爸啪啪啪能生出一堆妖寶寶。啪啪啪就是建構函式,俗稱造人。

三、人他媽會記錄啪啪啪的資訊,所以能透過人他媽找到啪啪啪的資訊——也就是說,能從原型物件回推到建構函式。

四、人他媽可以生很多寶寶,但這些寶寶只有一個媽媽,這就是原型的唯一性。

五、人他媽也是人他媽他媽生的。透過人他媽找到人他媽他媽,再往上找到人他媽他媽他媽……這條串起來的關係,就叫原型鏈。

六、原型鏈不是無限延伸的。沿著人他媽一路往上找,最後你會發現再上面的都不是人了——原型鏈最終指向 null。

七、人他媽生的人有人樣,妖他媽生的妖有妖的模樣,這叫繼承。

八、你繼承了你媽的膚色,你媽繼承了你外婆的膚色……這就是原型鏈上的繼承。

九、你沒有自己的房子,那你家指的就是你媽家;你媽也沒有,那就往上指到你外婆家……這就是原型鏈的向上搜尋。

十、你會繼承你媽的樣子,但你可以去染髮洗剪吹,也就是說物件的屬性可以自訂,並覆寫掉繼承來的值。

十一、即使你染成黃毛,也改不了你媽的樣子;你媽生的弟弟妹妹跟你的黃毛毫無關係——物件實例改不動原型的屬性。

十二、但要是你家被你玩火燒了,那你家、你媽家、你弟他們家全遭殃,這就是原型屬性的共享。

十三、你媽外號阿珍,鄰居都叫你阿珍兒;等你媽把頭髮做成金毛獅王,鄰居改口叫你金毛獅王子——這叫原型的動態性。

十四、你媽愛美跑去韓國整形,整到你外婆都認不出來。即使頭髮換回飄柔,鄰居還是叫你金毛獅王子,因為沒人認得她了——整形後的她其實已經回爐重造,這就是原型的整體重寫。

好了,比喻講完。Don't BB,Show me the code:

 function Person (name) {
    this.name = name;
}

function Mother () { }

Mother.prototype = {
    // Mother 的原型
    age: 18,
    home: ['Beijing', 'Shanghai']
};

Person.prototype = new Mother();   // Person 的原型為 Mother

// 用 chrome 開發者工具查看,提供了 __proto__ 介面查看原型
var p1 = new Person('Jack');   // p1: 'Jack'; __proto__: 18, ['Beijing','Shanghai']
var p2 = new Person('Mark');   // p2: 'Mark'; __proto__: 18, ['Beijing','Shanghai']

p1.age = 20;
/* 實例改不了原型的基本值屬性,正如你洗剪吹染黃毛跟你媽無關
 * 這只是在 p1 實例上新增一個普通屬性,等同 var o = {}; o.age = 20;
 * p1: 多了 age 屬性,而 __proto__ 仍是 Mother.prototype,age=18
 * p2: 只有 name 屬性,__proto__ 同上 */

p1.home[0] = 'Shenzhen';
/* 原型中「引用型別」屬性的共享,正如你燒了你家就是燒了全家
 * p1: 'Jack', 20; __proto__: 18, ['Shenzhen','Shanghai']
 * p2: 'Mark'; __proto__: 18, ['Shenzhen','Shanghai'] */

p1.home = ['Hangzhou', 'Guangzhou'];
/* 其實跟 p1.age = 20 是同一種操作
 * p1: 'Jack', 20, ['Hangzhou','Guangzhou']; __proto__: 18, ['Shenzhen','Shanghai']
 * p2: 'Mark'; __proto__: 18, ['Shenzhen','Shanghai'] */

delete p1.age;
/* 刪掉自訂屬性後,原本被覆寫的原型值重見天日——這就是向上搜尋機制
 * p1: 'Jack', ['Hangzhou','Guangzhou']; __proto__: 18, ['Shenzhen','Shanghai'] */

Person.prototype.lastName = 'Jin';
/* 改寫原型,動態反映到實例中,正如你媽變新潮了,鄰居說你是潮婦的兒子
 * 注意這裡改的是 Person 的原型,等同往 Mother 上加一個 lastName
 * 並不是改 Mother.prototype,改動不同層次效果差很多
 * p1: 'Jack', [...]; __proto__: 'Jin'; __proto__: 18, [...]
 * p2: 'Mark'; __proto__: 'Jin'; __proto__: 18, [...] */

Person.prototype = {
    age: 28,
    address: { country: 'USA', city: 'Washington' }
};
var p3 = new Person('Obama');
/* 整體重寫原型!此時 Person 的原型已換成全新物件,等於換了個娘
 * 理解方式:var a = 10; b = a; a = 20; c = a; → b 不變,變的是 c
 * p1、p2 完全不受影響,p3 則指向新原型 */

Mother.prototype.no = 9527;
/* 改寫「原型的原型」,動態反映到實例中
 * 注意這裡改的是 Mother.prototype,p1、p2 會變,
 * 但 p3 早已與 Mother 無關,不受影響 */

Mother.prototype = { car: 2, hobby: ['run','walk'] };
var p4 = new Person('Tony');
/* 整體重寫原型的原型!由於 Person 已與 Mother 斷開,Mother 怎麼變都不影響 Person
 * p4: 'Tony'; __proto__: 28 {country: 'USA', city: 'Washington'} */

Person.prototype = new Mother();   // 再次綁定
var p5 = new Person('Luffy');
// 若要重新套用那些改動,就得把 Person 的原型重新綁回 Mother
// p5: 'Luffy'; __proto__: 2, ['run','walk']

p1.__proto__.__proto__.__proto__.__proto__   // null,原型鏈的終點
Mother.__proto__.__proto__.__proto__         // null,原型鏈的終點

看到這裡應該大致能理解了吧?接著把 p1.age = 20、p1.home = [...] 和 p1.home[0] = 'Shenzhen' 這三種寫法講清楚。

前兩句其實不難,先把原型拋到腦後,想想我們平常怎麼幫一個普通物件加屬性:

 var obj = new Object();
obj.name = 'xxx';
obj.num = [100, 200];

這樣一比對就通了,完全一樣的道理。

那為什麼 p1.home[0] = 'Shenzhen' 不會在 p1 底下新建一個 home 陣列、再把首位設為 Shenzhen 呢?想想上面那個 obj,如果寫成 obj.name = 'xxx' 而 obj 根本還沒定義,你只會得到一個錯誤。同理,p1.home[0] 裡的 home 在 p1 上並不存在,自然無法一步定義 home[0]。若真要在 p1 底下建 home 陣列,得這樣寫:

 p1.home = [];
p1.home[0] = 'Shenzhen';

而它之所以不直接報錯,是因為原型鏈有一套搜尋機制。當我們讀取 p1.home 時,引擎先在實例上找,找不到就往原型找,再找不到就再上一層……一路到原型鏈終點 null 都沒找到,才回傳 undefined。p1.home[0] 走的是同一套流程,而這次我們在 Mother 的原型裡找到了它,所以修改它就等於修改了 Mother 的原型。

一句話總結:p1.home[0] = 'Shenzhen' 等同於 Mother.prototype.home[0] = 'Shenzhen'。

由此可見,原型鏈繼承最大的問題就在屬性共享。很多時候我們只想共享方法、不想共享屬性,理想狀態下每個實例都該有自己獨立的屬性。於是就有了下面兩種改良寫法。

一、組合繼承

 function Mother (age) {
    this.age = age;
    this.hobby = ['running','football'];
}
Mother.prototype.showAge = function () {
    console.log(this.age);
};

function Person (name, age) {
    Mother.call(this, age);   // 第二次執行
    this.name = name;
}
Person.prototype = new Mother();   // 第一次執行
Person.prototype.constructor = Person;
Person.prototype.showName = function () {
    console.log(this.name);
};

var p1 = new Person('Jack', 20);
p1.hobby.push('basketball');   // p1: 'Jack'; __proto__: 20, ['running','football']

var p2 = new Person('Mark', 18);   // p2: 'Mark'; __proto__: 18, ['running','football']

結果如下:

第一次執行時,得到的是 Person.prototype.age = undefined 與 Person.prototype.hobby = ['running','football'];第二次執行(也就是 new Person('Jack', 20))時,得到 p1.age = 20、p1.hobby = ['running','football'],push 之後才變成三個元素。只要把 this 依序替換一下,這個結果就不難理解。實在繞不出來的話,試著把腦中那些術語丟掉,把自己當成瀏覽器從上到下跑一遍程式碼,答案自然浮現。

關鍵在於第二次呼叫建構函式 Mother() 時,我們在實例上複製了一份原型屬性,做到與原型的分離獨立。那第一次呼叫好像沒什麼用?確實可以省掉,這就引出了寄生組合式繼承。

二、寄生組合式繼承

 function object(o){
    function F(){}
    F.prototype = o;
    return new F();
}

function inheritPrototype(Person, Mother){
    var prototype = object(Mother.prototype);
    prototype.constructor = Person;
    Person.prototype = prototype;
}

function Mother (age) {
    this.age = age;
    this.hobby = ['running','football'];
}
Mother.prototype.showAge = function () {
    console.log(this.age);
};

function Person (name, age) {
    Mother.call(this, age);
    this.name = name;
}

inheritPrototype(Person, Mother);

Person.prototype.showName = function () {
    console.log(this.name);
};

var p1 = new Person('Jack', 20);
p1.hobby.push('basketball');   // p1: 'Jack'; __proto__: 20, ['running','football']

var p2 = new Person('Mark', 18);   // p2: 'Mark'; __proto__: 18, ['running','football']

結果如下:

原型上不再有 age 與 hobby,只剩兩個方法,正是我們想要的結果。關鍵在 object(o):它借了一個臨時建構函式 F,巧妙避開直接呼叫 new Mother(),再把原型為 o 的新物件傳回去,完成原型鏈的設定。很繞對吧?那是因為我們不能直接寫 Person.prototype = Mother.prototype。

小結

說了這麼多,核心其實只有一句:屬性的共享與獨立該怎麼控制。當你的實例需要獨立屬性,所有做法的本質都是「在實例上建立屬性」。若不計較太多,大可直接在 Person 裡定義要獨立的屬性去覆寫原型。總之,使用原型繼承時,對原型上的屬性要格外小心,因為它們都是牽一髮而動全身的存在。

最後順手把 JS 建立物件的幾種模式羅列一下,目前最常用的是混合模式,熟悉的朋友可以直接跳到文末。

1)原始模式

 // 物件字面量
var person = {
    name: 'Jack',
    age: 18,
    sayName: function () { alert(this.name); }
};

// Object 建構函式
var person = new Object();
person.name = 'Jack';
person.age = 18;
person.sayName = function () { alert(this.name); };

問題很明顯:要大量建立 person1、person2……每次都敲一堆程式碼,資深的 Control+C 選手也吃不消。於工廠模式登場。

2)工廠模式

 function creatPerson (name, age) {
    var temp = new Object();
    temp.name = name;
    temp.age = age;
    temp.sayName = function () { alert(this.name); };
    return temp;
}

工廠模式就是量產,指定姓名年齡就能批量造人,確實解放雙手。但缺點是「暗箱操作」——你無法辨識這個物件到底屬於什麼型別(instanceof 測試只會得到 Object),而且每次造人都要新建一個 temp 物件,程式碼臃腫。

3)建構函式模式

 function Person (name, age) {
    this.name = name;
    this.age = age;
    this.sayName = function () { alert(this.name); };
}

var p1 = new Person('Jack', 18);
Person('Jack', 18);   // 屬性方法都掛到 window 上

它與 C++、Java 的建構函式概念相近,容易理解,而且 Person 可以用來做型別識別(instanceof 測試會通過 Person 與 Object)。但所有實例依然是各自獨立的,不同實例的 sayName 其實是不同的函式物件。把 sayName 當成一個普通物件來想就好懂了:張三的 sayName 和李四的 sayName 是兩個存在,而我們顯然期望它們共用同一份以節省記憶體。

4)原型模式

 function Person () {}
Person.prototype.name = 'Jack';
Person.prototype.age = 18;
Person.prototype.sayName = function () { alert(this.name); };

// 字面量寫法
function Person () {}
Person.prototype = {
    name: 'Jack',
    age: 18,
    sayName: function () { alert(this.name); }
};

var p1 = new Person();   // name = 'Jack'
var p2 = new Person();   // name = 'Jack'

這裡要注意的是原型屬性與方法的共享:所有實例都只是引用原型上的同一份內容,任何一處改動都會連帶影響其他實例。

5)混合模式(建構函式 + 原型)

 function Person (name, age) {
    this.name = name;
    this.age = age;
}

Person.prototype = {
    hobby: ['running','football'],
    sayName: function () { alert(this.name); },
    sayAge: function () { alert(this.age); }
};

var p1 = new Person('Jack', 20);   // p1: 'Jack', 20; __proto__: ['running','football'], sayName, sayAge
var p2 = new Person('Mark', 18);   // p2: 'Mark', 18; __proto__: ['running','football'], sayName, sayAge

做法是把需要獨立的屬性放進建構函式,可以共享的部分掛到原型上,這樣既省記憶體又保留了實例的獨立性,是目前最實用的組合。

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