有些知識當時實在看不懂的話,可以先暫且放下,留在以後再看,也許就能看懂了。
幾個月前,抱著《JavaScript 高級程序設計(第三版)》,啃完「創建對象」後,就開始啃「繼承」。然而啃完「原型鏈」實在看不下去,腦子越來越亂,於是把它扔在一邊,繼續看後面的內容。現在利用這個暑假終於搞懂了繼承,就把筆記整理出來。
先從原文中摘錄幾個重點:
prototype 屬性訪問原型對象;[[prototype]] 內部屬性訪問原型對象,瀏覽器實現了 __proto__ 屬性供實例訪問原型對象;Function.prototype 是對象,既然是對象,那麼就是 Object 的實例對象。有兩種方法可以檢測原型與實例的關係:
instanceof:判斷該對象是否為另一個對象的實例。其內部運算機理如下:
function instance_of(L, R){//L 表示左表達式,R 表示右表達式 var O = R.prototype;// 取 R 的顯示原型 L = L.__proto__; // 取 L 的隱式原型 while(true) { if(L === null) return false; if(O === L)// 重點:當 O 嚴格等於 L 時,返回 true return true; L = L.__proto__; } }
isPrototypeOf():測試一個對象是否存在於另一個對象的原型鏈上。
缺點:1. 引用類型值的原型屬性會被實例共享;2. 建立子類型實例時,無法向超類型的構造函數傳遞參數。
function Father(){ this.name ="father"; this.friends = ['aaa','bbb']; } function Son(){ } Son.prototype = new Father(); Son.prototype.constructor = Son; var s1 =new Son(); var s2 =new Son(); console.log(s1.name);// father console.log(s2.name);// father s1.name = "son"; console.log(s1.name);// son console.log(s2.name);// father console.log(s1.friends);// ["aaa", "bbb"] console.log(s2.friends);// ["aaa", "bbb"] s1.friends.push('ccc','ddd'); console.log(s1.friends);// ["aaa", "bbb", "ccc", "ddd"] console.log(s2.friends);// ["aaa", "bbb", "ccc", "ddd"]
實現方法:在子類型構造函數內部調用超類型構造函數(使用 apply() 或 call() 方法)。
優點:解決了原型中引用類型屬性的問題,並且子類可以向超類傳參。
缺點:子類實例無法訪問父類(超類)原型中定義的方法,函數復用便無從談起。
function Father(name,friends){ this.name = name; this.friends = friends; } Father.prototype.getName = function(){ return this.name; }; function Son(name){ // 注意:為確保 Father 構造函數不會重寫 Son 構造函數的屬性, // 請將調用 Father 構造函數的代碼放在 Son 中定義的屬性的前面。 Father.call(this,name,['aaa','bbb']); this.age = 22; } var s1 =new Son('son1'); var s2 =new Son('son2'); console.log(s1.name);// son1 console.log(s2.name);// son2 s1.friends.push('ccc','ddd'); console.log(s1.friends);// ["aaa", "bbb", "ccc", "ddd"] console.log(s2.friends);// ["aaa", "bbb"] // 子類實例無法訪問父類原型中的方法 s1.getName(); // TypeError: s1.getName is not a function s2.getName(); // TypeError: s2.getName is not a function
實現方法:使用原型鏈實現對原型屬性和方法的繼承,並透過借用構造函數來實現對實例屬性的繼承。
function Father(name,friends){ this.name = name; this.friends = friends; } Father.prototype.money = "100k $"; Father.prototype.getName = function(){ console.log(this.name); }; function Son(name,age){ // 繼承父類的屬性 Father.call(this,name,['aaa','bbb']); this.age = age; } // 繼承父類原型中的屬性和方法 Son.prototype = new Father(); Son.prototype.constructor = Son; Son.prototype.getAge = function(){ console.log(this.age); }; var s1 =new Son('son1',12); s1.friends.push('ccc'); console.log(s1.friends);// ["aaa", "bbb", "ccc"] console.log(s1.money);// 100k $ s1.getName(); // son1 s1.getAge(); // 12 var s2 =new Son('son2',24); console.log(s2.friends);// ["aaa", "bbb"] console.log(s2.money);// 100k $ s2.getName(); // son2 s2.getAge(); // 24
組合繼承避免了單方面使用原型鏈或構造函數的缺陷,融合兩者優點,成為 JavaScript 中最常用的繼承模式,但它也有缺陷,後面會專門提到。
實現思路:借助原型,基於已有對象建立新對象,同時不必為此建立自定義類型。為達到這個目的,引入下面的函數:
function obj(o){ function F(){} F.prototype = o; return new F(); } var person1 = { name: "percy", friends: ['aaa','bbb'] }; var person2 = obj(person1); person2.name = "zyj"; person2.friends.push('ccc'); console.log(person1.name);// percy console.log(person2.name);// zyj console.log(person1.friends);// ["aaa", "bbb", "ccc"] console.log(person2.friends);// ["aaa", "bbb", "ccc"]
ECMAScript 5 透過新增 Object.create() 方法規範化了原型式繼承。在傳入一個參數的情況下,Object.create() 和 obj() 的行為相同:
var person1 = { name: "percy", friends: ['aaa','bbb'] }; var person2 = Object.create(person1); person2.name = "zyj"; person2.friends.push('ccc'); console.log(person1.name);// percy console.log(person2.name);// zyj console.log(person1.friends);// ["aaa", "bbb", "ccc"] console.log(person2.friends);// ["aaa", "bbb", "ccc"]
在沒有必要大費周章建立構造函數,而只想讓一個對象與另一個對象保持相似的情況下,可以選擇這種繼承。
寄生式繼承是與原型式繼承緊密相關的一種思路。
實現思路:建立一個僅用於封裝繼承過程的函數,該函數在內部以某種方式增強對象,最後再返回對象。
function obj(o){ function F(){} F.prototype = o; return new F(); } function createPerson(original){// 封裝繼承過程 var clone = obj(original);// 建立對象 clone.showSomething = function(){// 增強對象 console.log("Hello world!"); }; return clone;// 返回對象 } var person = { name: "percy" }; var person1 = createPerson(person); console.log(person1.name);// percy person1.showSomething(); // Hello world!
先說說前面組合繼承的缺陷。組合繼承最大的問題是,無論什麼情況下都會調用兩次父類的構造函數:一次是在建立子類原型時,另一次是在調用子類構造函數時(子類構造函數內部又調用了父類的構造函數)。
function Father(name,friends){ this.name = name; this.friends = friends; } Father.prototype.money = "100k $"; Father.prototype.getName = function(){ console.log(this.name); }; function Son(name,age){ // 繼承父類的屬性 Father.call(this,name,['aaa','bbb']);// 第二次調用 Father(),實際是在 new Son() 時才會調用 this.age = age; } // 繼承父類原型中的屬性和方法 Son.prototype = new Father();// 第一次調用 Father() Son.prototype.constructor = Son;
第一次調用使子類的原型成了父類的一個實例,從而子類的原型得到了父類的實例屬性;第二次調用則使子類的實例也得到了父類的實例屬性;而子類的實例屬性預設會屏蔽掉子類原型中與其重名的屬性。所以經過這兩次調用,子類原型中出現了多餘的屬性,於是引入寄生組合式繼承來解決這個問題。
寄生組合式繼承背後的思路是:不必為了指定子類的原形而調用父類的構造函數,我們所需要的無非就是父類原型的一個副本而已。本質上,就是使用寄生式繼承來繼承父類的原型,然後將結果返回給子類的原型。
function obj(o){ function F(){} F.prototype = o; return new F(); } function inheritPrototype(son,father){ var prototype = obj(father.prototype);// 建立對象 prototype.constructor = son; // 增強對象 son.prototype = prototype; // 返回對象 } function Father(name,friends){ this.name = name; this.friends = friends; } Father.prototype.money = "100k $"; Father.prototype.getName = function(){ console.log(this.name); }; function Son(name,age){ // 繼承父類的屬性 Father.call(this,name,['aaa','bbb']); this.age = age; } // 使用寄生式繼承繼承父類原型中的屬性和方法 inheritPrototype(Son,Father); Son.prototype.getAge = function(){ console.log(this.age); }; var s1 =new Son('son1',12); s1.friends.push('ccc'); console.log(s1.friends);// ["aaa", "bbb", "ccc"] console.log(s1.money);// 100k $ s1.getName(); // son1 s1.getAge(); // 12 var s2 =new Son('son2',24); console.log(s2.friends);// ["aaa", "bbb"] console.log(s2.money);// 100k $ s2.getName(); // son2 s2.getAge(); // 24
優點:使子類原型避免了繼承父類中不必要的實例屬性。開發人員普遍認為,寄生組合式繼承是實現基於類型繼承的最理想方式。
最後,推薦兩篇很紮實的文章:Javascript – How Prototypal Inheritance really works 與 JavaScript's Pseudo Classical Inheritance diagram。摘錄後者的一張硬圖過來:

看完之後,是不是秒懂原型鏈了呢?以上就是對 JavaScript 繼承的整理,後續會繼續補充相關資料,謝謝大家的支持!