ECMAScript 支援兩種開發模式:一是函式式(過程化),二是面向對象(OOP)。本文將系統梳理物件建立、原型與繼承的相關知識。
一、建立物件
1. 一般方式建立物件
// 創建一個對象,然後給這個對象新的屬性和方法; var box = new Object(); // 創建一個Object對象; box.name = 'lee'; // 創建一個name屬性並賦值; box.age = 100; box.run = function(){ // 創建一個run()方法並返回值; return this.name+this.age+'運行中...'; } console.log(box.run()); // 輸入屬性和方法的值; // 缺點:想創建類似的對象,就會產生大量的代碼;
2. 工廠模式建立物件
// 這種方法就是為了解決實例化對象產生大量代碼重復的問題; function createObject(name,age){ // 集中創建函數體; var obj = new Object; // 函數體內創建Object; obj.name = name; obj.age = age; obj.run = function(){ return this.name+this.age+"運行中..."; }; return obj; } var box1 = createObject("lee",100); // 實例化;調用函數並傳參; var box2 = createObject("jack",200); // 實例二; console.log(box1.run()+box2.run()); // 實例保持相對獨立; // 缺點:對象與實例的識別問題;無法搞清楚它們到底是那個對象的實例; console.log(typeof box1); // Object;
3. 構造函式建立物件
// ECMAScript采用構造函數(構造方法)可用來創建特定的對象; function Box(name,age){ // 構造函數模式; this.name = name; // this代表對象Box; this.age = age; this.run = function(){ return this.name+this.age+"運行中..."; }; } var box1 = new Box("lee",100); // 要創建對象的實例必須用new操作符; var box2 = new Box("jack",200); // box1和box2都是Box對象的實例; console.log(box1 instanceof Box); // true;很清晰的識別box1從屬於Box; // 使用構造函數,即解決了重復實例化的問題,有解決了對象識別的問題;
構造函式與工廠模式的不同之處:(1) 構造函式不顯式建立物件(new Object);(2) 直接把屬性與方法賦值給 this;(3) 沒有 return 敘述。構造函式的規範是:函式名與實例化名稱相同且首字母大寫;建立實例時必須使用 new 運算子。
// 構造函數和普通函數的區別: var box = new Box('lee',100); // 構造模式調用; Box('lee',200); // 普通模式調用,無效; var o = new Object(); Box.call(o,'jack',200); // 對象冒充調用; // 將Box對象作用域擴充到對象o;Box()方法的運行環境已經變成了對象o裡;
構造函式的問題:每次用構造函式建立實例時,其中的方法都會在每個實例上重新建立一次。由於 ECMAScript 中的函式本身也是物件,每定義一個函式就等同於實例化一個物件,這樣會導致不同的作用域鏈與標識符解析。
二、原型
我們建立的每個函式都有一個 prototype(原型)屬性,它是一個物件,用於存放可由該型別所有實例共享的屬性與方法。原型的好處在於讓所有實例共享其中的內容,不必在構造函式裡重複定義。
1. 原型模式(透過 prototype 新增屬性與方法)
1.原型模式 function Box(){} // 聲明構造函數; Box.prototype.name = 'Lee'; // 在原型裡添加屬性和方法; Box.prototype.age = 100; Box.prototype.run = function() { return this.name+this.age+'運行中...'; }; var box1 = new Box(); var box2 = new Box(); console.log(box1.run==box2.run); // =>true;方法引用的地址保持一致; // 在原型中多了兩個屬性,這兩個原型屬性都是創建對象時自動生成的; // 1.__proto__:構造函數指向原型對象的一個指針;它的作用:指向構造函數的原型的屬性constructor; 14// IE浏覽器在腳本訪問__proto__會不能識別; 15 // 判斷一個實例對象是否指向了該構造函數的原型對象,可以使用isPrototypeOf()方法來測試; console.log(Box.prototype.isPrototypeOf(box)); // =>true; 只要實例化對象,即都會指向; // 原型模式的執行流程: // 1.先查找構造函數對象的實例裡的屬性或方法,若有,立刻返回; // 2.若構造函數對象的實例裡沒有,則去它的原型對象裡找,若有,就返回; // 雖然我們可以通過對象實例訪問保存在原型中的值,但卻不能訪問通過對象實例重寫原型中的值; var box1 = new Box(); console.log(box1.name); // Lee; 原型裡的值; bo1.name = 'jack'; console.log(box1.name); // Jack;實例自己賦的值; var box2 = new Box(); console.log(box2.name); // Lee;原型裡的值;沒有被box1修改; // 如果想要box1繼續訪問原型裡的值,可以把構造函數裡的屬性刪除即可; delete box1.name; // 刪除實例自己的屬性; console.log(box1.name); // Lee; 原型裡原來的值;

2. 原型與 in 運算子
要判斷屬性是在實例上還是在原型上,可用 hasOwnProperty() 驗證;而 in 運算子只要物件能存取該屬性(不論在實例或原型)就會回傳 true。
3. 更簡潔的原型語法(原型 + 字面量模式)
function Box(){}; Box.prototype = { // 以字面量形式創建包含屬性和方法的新對象; name:'Lee', age:100, run:function(){ return this.name+this.age+'運行中...'; } }; // 使用構造函數創建原型對象和使用字面量創建原型對象在使用上基本相同; // 但是,使用字面量創建的原型對象使用constructor屬性不會指向實例,而是指向原型對象Object;構造函數的方式則相反; var box = new Box(); console.log(box instanceof Box); console.log(box instanceof Object); console.log(box.constructor == Box); // 字面量方式,返回false; console.log(box.constructor == Object); // 字面量方式,返回true; // 如果想讓字面量方式的constructor指向實例對象: Box.prototype = { constructor:Box, // 直接強制指向即可; } // PS:字面量方式為什麼constructor會指向Object? // 因為Box.prototype={}這種字面量寫法就是創建一個新對象; // 而每創建一個函數,就會同時創建它的prototype,這個對象也會自動獲取constructor屬性; // 所以,新對象的constructor重寫了Box原來的constructor,因此指向了新對象, // 那個新對象沒有指定構造函數,那麼就默認為是Object;
4. 原型的動態性(重寫會覆蓋先前內容)
// 原型的聲明是有先後順序的,所以,重寫的原型會切斷之前的原型; function Box(){}; Box.prototype = { constructor:Box, name:'Lee', age:100, run:function(){ return this.age+'運行中...'; } }; Box.prototype = { // 原型重寫了,覆蓋了之前的原型; age:200, run:function(){ return this.age+'運行中...'; } } var box = new Box(); console.log(box.run()); // =>200運行中...; // 重寫原型對象切斷了現有原型與任何之前已經存在的對象實例之間的聯系;對象實例引用的仍然是最初的原型;
5. 原生物件原型
原型不僅可用於自訂物件,ECMAScript 內建的引用型別也都基於原型實作,例如 Array.prototype.sort、String.prototype.substring。
6. 原型物件的問題
// 原型模式創建對象缺點:省略了構造函數傳參初始化這一過程,帶來的缺點就是初始化的值都是一致的; // 而原型最大的有點就是共享,屬性共享; // 但是,如果原型中的屬性包含引用類型(對象),共享就會存在一定問題; function Box(){}; Box.prototype = { constructor:Box, name:'Lee', age:100, family:['father','mother'], run:function(){ return this.name+this.age+this.family; } }; var box1 = new Box(); box1.family.push('sister'); // 為box1的family屬性添加了sister;而這個屬性被共享到原型了; console.log(box1.run()); // =>Lee100father,mother,sister; var box2 = new Box(); console.log(box2.run()); // =>Lee100father,mother,sister; // 數據共享導致實例化出的數據不能保存自己的特性;
7. 組合使用構造函式模式(不共享的資料)與原型模式(共享的資料)
// 為了解決構造傳參和共享問題,組合構造函數+原型模式: function Box(name,age){ // 不共享的使用構造函數; this.name = name; this.age = age; this.family = ['father','moter']; }; Box.prototype = { // 共享的使用原型模式; constructor:Box, run:function(){ return this.name+this.age+this.family; } }; // PS:這種混合模式很好的解決了傳參和引用共享的大難題;是創建對象比較好的方法;
8. 動態原型模式(把原型封裝進構造函式)
// 原型模式,不管是否調用了原型中的共享方法,它都會初始化原型中的方法; // 並且在聲明一個對象時,構造函數+原型讓人感覺怪異;最好把構造函數和原型封裝到一起; function Box(name,age){ // 將所有信息封裝到構造函數體內; this.name = name; this.age = age; // 當第一次調用構造函數時,run()方法不存在,然後執行初始化原型; // 當第二次調用,就不會初始化,並且第二次創建新對象,原型也不會載初始化; // 這樣既得到了封裝,又實現了原型方法共享,並且屬性都保持獨立; if(typeof this.run != 'function'){ // 僅在第一次調用時初始化; Box.prototype.run = function (){ return this.name+this.age+'運行中...'; }; } }; var box = new Box('lee',10); console.log(box.run()); // PS:使用動態原型模式,要注意一點,不可以再使用字面量的方式重寫原型,因為會切斷實例和新原型之間的聯系;
9. 寄生構造函式
// 寄生構造函數,其實就是工廠模式+構造模式;這種模式比較通用,但不能確定對象關系; function Box(name,age){ var obj = new Object(); obj.name = name; obj.age = age; obj.run = function (){ return this.name+this.age+'運行中...'; }; return obj; }
三、繼承
1. 原型鏈
// 繼承是面向對象中一個比較核心的概念; // 其他正統面向對象語言都會用兩種方式實現繼承:一個是接口實現,一個是繼承; // 而ECMAScript只支持繼承,不支持接口實現,而實現繼承的方式依靠原型鏈完成; // 實質:利用原型讓一個引用類型繼承另一個引用類型的屬性和方法; // 原型繼承鏈:Box ==>> Desk ==>> Table; function Box(){ // Box構造; this.name = 'Lee'; } function Desk(){ // Desk構造; this.age = 100; } Desk.prototype = new Box(); // 通過創建Box實例,並賦值給Desk.prototype實現的;通過原型,形成鏈條; // 實質是:重寫了Desk的原型對象,取而代之的是一個新類型Box的實例; // 也就是說原來存在於Box實例中的屬性和方法,現在也存在與Desk.prototype中了; var desk = new Desk(); console.log(desk.age); // 100; console.log(desk.name); // =>Lee; function Table(){ this.level = 'AAA'; } Table.prototype = new Desk(); // 繼續原型鏈繼承;Table繼承了Desk; var table = new Table(); console.log(table.name); // Lee;
2. 原型與實例的關係
// PS:以上原型鏈繼承缺少一環,那就是Object,所有的構造函數都繼承自Object; // 而繼承Object是自動完成的,並不需要手動繼承; console.log(table instanceof Object); // =>true; console.log(desk instanceof Table); // =>false;Desk是Table的超類; console.log(table instanceof Desk); // =>true; console.log(table instanceof Box); // =>true; // 在JS中,被繼承的函數稱為超類型(父類,基類); // 繼承的函數稱為子類型(子類,派生類); // 繼承問題: // 字面量重寫原型會中斷關系; // 子類型無法給超類型傳遞參數;
3. 借用構造函式(物件冒充)
// 在子類型構造函數的內部調用超類型構造函數; function Box(age){ this.name = ['Lee','Jack','Hello']; this.age = age; } function Desk(age){ // 繼承了Box;同時還傳遞了參數; // 這樣一來,就會在新Desk對象上執行Box()函數中定義的所有對象初始化代碼; Box.call(this,age); // 對象冒充,Desk繼承Box,並可以給超類型傳參; // 為了確保Box構造函數不會重寫子類型的屬性,可以在超類型構造函數後,再添加應該在子類型中定義的屬性; this.height = 175; } var desk = new Desk(200); // 向Desk()函數傳參,再通過函數冒用向Box()函數傳參; console.log(desk.age); // =>200; console.log(desk.name); // =>['Lee','Jack','Hello']; desk.name.push('AAA'); // =>添加的新數據,只添加給desk; console.log(desk.name); // =>['Lee','Jack','Hello','AAA'];
4. 組合繼承(原型鏈 + 借用構造函式)
// 使用原型鏈實現對原型屬性和方法的繼承; // 通過借用構造函數來實現對實例屬性的繼承; // 這樣,既通過在原型上定義方法實現了函數復用,又能保證每個實例都有他自己的屬性; function Box(age){ // 構造函數; this.name = ['Lee','Jack','Hello']; this.age = age; } Box.prototype.run = function(){ // 原型; return this.name+this.age; } function Desk(age){ Box.call(this,age); // 繼承屬性; 對象冒充; 將Box對象的作用域擴充到Desk中,Desk就會繼承Box裡的屬性和方法; } Desk.prototype = new Box(); // 繼承方法; 原型鏈繼承; var desk = new Desk(100); console.log(desk.run()); // =>Lee,Jack,Hello100 // 最常用的繼承模式;
5. 原型式繼承
// 這種繼承借助原型並基於已有的對象創建對象,同時還不必因此創建自定義類型; function obj(o){ // 傳遞一個字面量函數; function F(){}; // 創建一個構造函數; F.prototype = o; // 把字面量函數賦值給構造函數的原型; return new F(); // 返回實例化的構造函數; } var box = { // 字面量對象; name:'Lee', arr:['brother','sisiter'] }; var box1 = obj(box); console.log(box1.name); // =>Lee; box1.name = 'Jack'; console.log(box1.name); // =>Jack; console.log(box1.arr); // =>brother,sister; box1.arr.push('father'); // console.log(box1.arr); // =>brother,sister,father; var box2 = obj(box); console.log(box2.name); // =>Lee; console.log(box2.arr); // =>brother,sister,father;引用類型共享了;
6. 寄生式繼承
// 把原型式+工廠模式結合而來,目的是為了封裝創建對象的過程; // 創建一個僅用於封裝繼承過程的函數, function create(o){ // 封裝創建過程; var f = obj(o); f.run = function(){ return this.arr; // 同樣會共享引用; }; return f; }
7. 寄生組合式繼承
// 之前說過,組合式繼承是JS最常用的繼承模式; // 但是,組合式繼承也有問題: // 超類型在使用過程中會被調用兩次:一次是創建子類型的時候,另一次是在子類型構造函數的內部; function Box(name){ this.name = name; this.arr = ['brother','sister']; } Box.prototype.run = function(){ return this.name; } function Desk(name,age){ Box.call(this,name); // 第二次調用Box; this.age = age; } Desk.prototype = new Box(); // 第一次調用Box; // 寄生組合式繼承: // 通過借用構造函數來繼承屬性, // 通過原型鏈的混成形式來繼承方法; // 解決了兩次調用的問題; function obj(o){ function F(){}; F.prototype = o; return new F(); } function create(box,desk){ var f = obj(box.prototype); f.constructor = desk; desk.prototype = f; } function Box(name){ this.name = name; this.arr = ['brother','sister']; } Box.prototype.run = function(){ return this.name; } function Desk(name,age){ Box.call(this,name); this.age = age; } inheritPrototype(Box,Desk); // 通過這裡實現繼承; var desk = new Desk('Lee',100); desk.arr.push('father'); console.log(desk.arr); console.log(desk.run()); var desk2 = new Desk('Jack',200); console.log(desk2.arr); // 兩次引用問題解決;
四、小結
1. 建立物件
物件可在程式執行過程中動態建立與增強。在沒有 class 的情況下,可用下列模式建立:(1) 工廠模式,用簡單函式建立物件並回傳,後被構造函式模式取代;(2) 構造函式模式,可自訂引用型別並用 new 建立實例,缺點是成員(含函式)無法復用;(3) 原型模式,透過 prototype 指定共享的屬性與方法。實務上常組合兩者:構造函式定義實例屬性,原型定義共享屬性與方法。
2. 原型鏈
原型鏈透過把一個型別的實例賦值給另一個構造函式的原型來建立,子型別可存取超型別的所有屬性與方法。其問題在於實例會共享所有繼承而來的屬性,因此不宜單獨使用;解決方案是借用構造函式,讓每個實例擁有自己的屬性。最常用的繼承模式是組合繼承。
3. 繼承模式
(1) 原型式繼承:本質是對給定物件做淺複製,副本可進一步改造;(2) 寄生式繼承:基於物件建立、增強後回傳,可與組合繼承搭配以解決多次呼叫超型別的低效問題;(3) 寄生組合式繼承:兼具兩者優點,是實現基於型別繼承最有效的方式。