JavaScript進階教學之非extends的組合繼承詳解

2022-08-06 18:00:42

前言

繼承也是物件導向的特性之一，但是在 ES6 版本之前是沒有 extends 去實現繼承的，我們只能通過 建構函式 和 原型物件 來實現繼承，其中分別為建構函式來繼承屬性，原型物件來繼承方法，這種繼承模式被稱為 組合繼承

一：call() 的作用與使用

在開始講解組合繼承前我們先來了解一下 call() 方法，call() 方法可以改變 this 的指向，也可以呼叫函數等等，最主要的還是其改變指向的作用

語法格式	call( 目標this指向，引數1，引數2 ......)

1.1 使用 call() 來呼叫函數

call() 可以拿來直接用來呼叫函數

     <script>
        function eat(){
            console.log('我在吃午飯');
        }
        eat.call()
     </script>

1.2 使用 call() 來改變 this 的指向

call() 的第一個引數為你要改變的 this 的指向，這裡的 this 指的是 call 的呼叫者，此處函數呼叫不指定的話即指向 window，指定讓其指向新建立的物件 obj，只需要讓其第一個引數為 obj 物件即可，所以結果應該是第一個為 window，第二個為 obj 物件

     <script>
        function eat(){
            console.log(this);
        }
        var obj={
            'name':'小明',
            'age':18
        }  
        eat.call()
        eat.call(obj)
     </script>

二：利用建構函式繼承父屬性

我們已經知道組合繼承是由建構函式和原型物件一起來實現的，其中建構函式實現的是屬性的繼承，原型物件實現的是方法的繼承，這版塊就走進利用父建構函式完成屬性的繼承

2.1 實現過程

其實現非常容易，只需要在子建構函式中，使用 call 呼叫父建構函式（將其當做普通函數呼叫），其中在 call 方法中更改父建構函式中的 this 指向，由於 call 方法是在子建構函式中呼叫的，所以此處當做引數的 this 代表父建構函式中的 this 指向子建構函式的範例化物件，並傳參進去，所以相當於給子建構函式的範例化物件新增了屬性並賦值

     <script>
        //宣告父建構函式
        function Father(uname,uage,utel,sex){
            this.uname=uname;
            this.uage=uage;
            this.utel=utel;
            this.sex=sex;
        }
        //宣告子建構函式，但是想繼承父類別的uname，uage，utel等等屬性的賦值操作
        function Son(uname,uage,utel,sex){
            Father.call(this,uname,uage,utel,sex)
        }
        var son1=new Son('張三',19,12345,'男')
        console.log(son1);
     </script>

2.1 實現過程分析

首先在子建構函式中使用 call 呼叫了父建構函式，並傳參給 call 的引數，其中第一個引數為 this 指向的改變，其餘為帶入的屬性值引數
我們知道建構函式中的 this 指向其範例化物件，所以本身父建構函式的 this 應該指向父建構函式的範例化物件，而此處 call 方法呼叫在子建構函式中，所以引數的指向更改為指向子建構函式的範例化物件
此處子建構函式的範例化物件就是 son1，所以父建構函式中的 this 指向的均是 son1,
所以就給 son1 新增並賦值了 uname，uage 等等屬性

三：利用原型物件繼承父方法

組合繼承的最後一版塊，利用原型物件來繼承方法，此處我們說明的是存放在建構函式的原型物件裡的公共方法的繼承

3.1 繼承父方法的錯誤演示

錯誤的繼承就是直接將父親的原型物件賦值給子的原型物件，這樣確實也可行，但是如果給子原型物件新增子類特有的方法，那父原型物件也會加上這個方法

     <script>
        //宣告父建構函式
        function Father(uname,uage){
            this.uname=uname;
            this.uage=uage;
        }
        Father.prototype.money=function(){
            console.log('我有很多錢');
        }
        //宣告子建構函式
        Son.prototype=Father.prototype;
        function Son(uname,uage){
            Father.call(this,uname,uage)
        }
        var father1=new Father('爸爸',40)
        var son1=new Son('兒子',19)
        console.log(father1);
        console.log(son1);
     </script>

我們可以發現父子的原型物件中確實都有了這個方法，證明確實這個辦法是行得通的

但是其也有問題存在，當我們想給子原型物件單獨新增其特有的方法時，就會出問題

上述問題給子原型物件新增特有方法的錯誤範例：

     <script>
        //宣告父建構函式
        function Father(uname,uage){
            this.uname=uname;
            this.uage=uage;
        }
        Father.prototype.money=function(){
            console.log('我有很多錢');
        }
        //宣告子建構函式
        Son.prototype=Father.prototype;
        Son.prototype.school=function(){
            console.log('我去上學了');
        }
        function Son(uname,uage){
            Father.call(this,uname,uage)
        }
        var father1=new Father('爸爸',40)
        var son1=new Son('兒子',19)
        console.log(father1);
        console.log(son1);
     </script>

我們發現，我們確實給兒子新增上了兒子特有的方法，但是，父親的原型物件內也加上了這個方法，這並不滿足我們的預期，原因分析如下

問題原因

問題就在於我們的原型物件也是物件，物件是參照資料型別，參照資料型別的物件本質是在堆記憶體存放，是不能直接存取的，其存取是通過棧記憶體上的參照地址來找到去存取，而我們此處採用的等號賦值的方式，實際上是將其在棧記憶體上的參照地址拷貝過去了，二者指向了同一塊記憶體空間，所以更改子原型物件，父原型物件也改變了

3.2 繼承父方法的正確做法

正確的做法是讓其子原型物件物件等於父範例化物件 Son.prototype=new Father()，其實我感覺有種高內聚低耦合的韻味，減少了直接聯絡從而解決問題

     <script>
        //宣告父建構函式
        function Father(uname,uage){
            this.uname=uname;
            this.uage=uage;
        }
        Father.prototype.money=function(){
            console.log('我有很多錢');
        }
        //宣告子建構函式
        Son.prototype=new Father();
        Son.prototype.school=function(){
            console.log('我去上學了');
        }
        function Son(uname,uage){
            Father.call(this,uname,uage)
        }
        var father1=new Father('爸爸',40)
        var son1=new Son('兒子',19)
        console.log(father1);
        console.log(son1);
     </script>

問題得以解決，子原型物件有了自己特有的方法，並且也繼承了父親原型物件中的方法

3.2 繼承父方法的注意事項

我們以 Son.prototype=new Father() 這種方法繼承，看似已經天衣無縫，其實我們早就說過，採用等號賦值的方法會造成原型物件被覆蓋，裡面的建構函式 constructor 會被覆蓋掉，需要我們手動返回，所以七千萬要記得手動返回 constructor

     <script>
        //宣告父建構函式
        function Father(uname,uage){
            this.uname=uname;
            this.uage=uage;
        }
        Father.prototype.money=function(){
            console.log('我有很多錢');
        }
        //宣告子建構函式
        Son.prototype=new Father();
        Son.prototype.constructor=Son;  //手動返回建構函式constructor
        Son.prototype.school=function(){
            console.log('我去上學了');
        }
        function Son(uname,uage){
            Father.call(this,uname,uage)
        }
        var father1=new Father('爸爸',40)
        var son1=new Son('兒子',19)
        console.log(father1);
        console.log(son1);
        console.log(Son.prototype.constructor);
     </script>