JS實現繼承的幾種方式
前言：大多數語言都支持兩種繼承方式： 接口繼承和實現繼承 ，而javaScript中無法實現接口繼承，
javaScript只支持實現繼承，而且其實現繼承主要是依靠原型鏈來實現。
主要繼承方式如下：
1、原型鏈繼承
2、構造函數繼承
3、實例繼承
4、拷貝繼承
5、組合繼承（原型鏈繼承+構造函數繼承）
6、寄生組合式繼承

JS繼承的實現方式
既然要實現繼承，那麽首先我們得有一個父類，代碼如下：

// 定義一個動物類
function Animal (name) {
　　// 屬性
　　this.name = name || ‘Animal‘;
　　// 實例方法
　　this.sleep = function(){
 

　　console.log(this.name + ‘正在睡覺！‘);
　　}
}
// 原型方法
Animal.prototype.eat = function(food) {
　　console.log(this.name + ‘正在吃：‘ + food);
};

一、原型鏈繼承
核心： 將父類的實例作為子類的原型
基本思想：利用原型讓一個引用類型繼承另外一個引用類型的屬性和方法。
構造函數，原型，實例之間的關系：每個構造函數都有一個原型對象，原型對象包含一個指向構造函數的指針，而實例都包含一個指向原型對象的內部指針。
function Cat(){}
Cat.prototype = new Animal();
Cat.prototype.name = ‘cat‘;
 


//　Test Code
var cat = new Cat();
console.log(cat.name); //cat
cat.eat(‘fish‘); //cat正在吃：fish
cat.sleep(); //cat正在睡覺！
console.log(cat instanceof Animal); //true
console.log(cat instanceof Cat); //true
特點：
　　非常純粹的繼承關系，實例是子類的實例，也是父類的實例
　　父類新增原型方法/原型屬性，子類都能訪問到
　　簡單，易於實現
缺點：
　　無法實現多繼承
　　來自原型對象的引用屬性是所有實例共享的
　　創建子類實例時，無法向父類構造函數傳參
二、構造繼承
 

核心：使用父類的構造函數來增強子類實例，等於是復制父類的實例屬性給子類（沒用到原型）
基本思想：在子類型構造函數的內部調用超類構造函數，通過使用call()和apply()方法可以在新創建的對象上執行構造函數。

function Cat(name){
　　Animal.call(this);
　　this.name = name || ‘Tom‘;
}
// Test Code
var cat = new Cat();
console.log(cat.name); //Tom
cat.sleep(); //Tom正在睡覺
console.log(cat instanceof Animal); // false
console.log(cat instanceof Cat); // true
cat.eat(‘fish‘); //報錯
特點：
　　解決了1中，子類實例共享父類引用屬性的問題
　　創建子類實例時，可以向父類傳遞參數
　　可以實現多繼承（call多個父類對象）
缺點：
　　實例並不是父類的實例，只是子類的實例
　　只能繼承父類的實例屬性和方法，不能繼承原型屬性/方法
　　無法實現函數復用，每個子類都有父類實例函數的副本，影響性能
三、實例繼承
核心：為父類實例添加新特性，作為子類實例返回

function Cat(name){
　　var instance = new Animal();
　　instance.name = name || ‘Tom‘;
　　return instance;
}
// Test Code
var cat = new Cat();
console.log(cat.name) //Tom
cat.sleep(); //Tom正在睡覺
cat.eat(‘fish‘); // Tom正在吃：fish
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); // false
特點：
　　不限制調用方式，不管是new 子類()還是子類(),返回的對象具有相同的效果
缺點：
　　實例是父類的實例，不是子類的實例
　　不支持多繼承
四、拷貝繼承
function Cat(name){
　　var animal = new Animal();
　　for(var p in animal){
　　　　Cat.prototype[p] = animal[p];
　　}
　　Cat.prototype.name = name || ‘Tom‘;
}

// Test Code
var cat = new Cat();
console.log(cat.name) //Tom
cat.sleep(); //Tom正在睡覺
cat.eat(‘fish‘); //Tom正在吃：fish
console.log(cat instanceof Animal); // false
console.log(cat instanceof Cat); // true
特點：
　　支持多繼承
缺點：
　　效率較低，內存占用高（因為要拷貝父類的屬性）
　　無法獲取父類不可枚舉的方法（不可枚舉方法，不能使用for in 訪問到）
五、組合繼承
核心：通過調用父類構造，繼承父類的屬性並保留傳參的優點，然後通過將父類實例作為子類原型，實現函數復用
function Cat(name){
　　Animal.call(this);
　　this.name = name || ‘Tom‘;
}
Cat.prototype = new Animal();
Cat.prototype.constructor = Cat;

// Test Code
var cat = new Cat();
console.log(cat.name) //Tom
cat.sleep(); //Tom正在睡覺
cat.eat(‘fish‘); //Tom正在吃：fish
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); // true
特點：
　　彌補了方式2的缺陷，可以繼承實例屬性/方法，也可以繼承原型屬性/方法
　　既是子類的實例，也是父類的實例
　　不存在引用屬性共享問題
　　可傳參
　　函數可復用
缺點：
　　調用了兩次父類構造函數，生成了兩份實例（子類實例將子類原型上的那份屏蔽了）
六、寄生組合繼承
核心：通過寄生方式，砍掉父類的實例屬性，這樣，在調用兩次父類的構造的時候，就不會初始化兩次實例方法/屬性，避免的組合繼承的缺點
function Cat(name){
　　Animal.call(this);
　　this.name = name || ‘Tom‘;
}
(function(){
　　// 創建一個沒有實例方法的類
　　var Super = function(){};
　　Super.prototype = Animal.prototype;
　　//將實例作為子類的原型
　　Cat.prototype = new Super();
})();

// Test Code
var cat = new Cat();
console.log(cat.name) //Tom
cat.sleep(); //Tom正在睡覺
cat.eat(‘fish‘); //Tom正在吃：fish
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); //true

Cat.prototype.constructor = Cat; // 需要修復下構造函數
特點：
　　堪稱完美
缺點：
　　實現較為復雜

參考鏈接：https://www.cnblogs.com/humin/p/4556820.html；
參考鏈接：https://www.jb51.net/article/81766.htm

js幾種繼承方式（六種）