摘要：常用繼承方式主要分為種原型鏈繼承構(gòu)造函數(shù)繼承組合繼承原型式繼承寄生式繼承寄生組合繼承以及繼承多個(gè)對象。所以說，構(gòu)造函數(shù)基礎(chǔ)只能繼承父類的實(shí)例屬性和方法，不能繼承原型鏈上的屬性和方法。

JavaScript常用繼承方式主要分為(7種)：原型鏈繼承、構(gòu)造函數(shù)繼承、組合繼承、原型式繼承、寄生式繼承、寄生組合繼承以及繼承多個(gè)對象。

基本概念：重寫原型對象，賦予一個(gè)新的對象的實(shí)例。基本思想就是讓一個(gè)原型對象指向另一個(gè)父類的實(shí)例。

function Super() {
    //基本數(shù)據(jù)類型
    this.text = "Hello";
}
Super.prototype.getSuperText = function() {
    return this.text;
}
function Sub() {
    this.subText = "Word";
}

Sub.prototype = new Super();

const instance = new Sub();
console.log(instance);

特點(diǎn)：非常純粹的繼承關(guān)系，實(shí)例是子類的實(shí)例，也是父類的實(shí)例。父類新增原型方法或?qū)傩裕宇惗寄茉L問到。

優(yōu)點(diǎn)：簡單易于操作

缺點(diǎn)：對引用類型數(shù)據(jù)操作會互相（多個(gè)實(shí)例之間）影響

function Super() {
    //復(fù)雜對象，也就是引用類型
    this.value = [1, 2, 3, 4];
}
Super.prototype.getSuperValue = function() {
    return this.value;
}
function Sub() {
    this.subText = "Word";
}

Sub.prototype = new Super();

const instance1 = new Sub();
const instance2 = new Sub();

instance1.value.push(5);
console.log(instance2.value);

// (5)?[1, 2, 3, 4, 5]

//定義構(gòu)造函數(shù)
function Super(){
    this.value = [1, 2, 3, 4];
}
//新增屬性getSuperValue
Super.prototype.getSuperValue = function() {
    return this.value;
}
//sub每次執(zhí)行都要重新調(diào)用
function Sub(){
    Super.call(this);
}

const instance1 = new Sub();
instance1.value.push(5);
console.log(instance1.value);
// (5)?[1, 2, 3, 4, 5]

const instance2 = new Sub();
console.log(instance2.value);
// (4)?[1, 2, 3, 4]

構(gòu)造函數(shù)的特點(diǎn)：（對引用數(shù)據(jù)類型沒有影響）上面的代碼輸出instance1是1,2,3,4,5，instance2是1,2,3,4。這是因?yàn)閟ub每次在執(zhí)行時(shí)都是重新調(diào)用了一個(gè)super.call()，而且構(gòu)造函數(shù)在構(gòu)建對象的過程中，每次都是創(chuàng)建了一個(gè)新的object，因此每次調(diào)用sub都會執(zhí)行一遍super，每次執(zhí)行時(shí)都會有申請一個(gè)新的內(nèi)存空間，所以得到的兩個(gè)value值是不一樣互不影響的。

缺點(diǎn)：在整個(gè)構(gòu)造函數(shù)的基礎(chǔ)過程中，上面的代碼并沒有使用proto和prototype的屬性，沒有使用的話那么原型鏈就沒有接上。所以說，構(gòu)造函數(shù)基礎(chǔ)只能繼承父類的實(shí)例屬性和方法，不能繼承原型鏈上的屬性和方法。

通過調(diào)用父類構(gòu)造，繼承父類的屬性并保留傳參的優(yōu)點(diǎn)，然后通過將父類實(shí)例作為子類原型，實(shí)現(xiàn)函數(shù)復(fù)用。

保留了構(gòu)造函數(shù)繼承與原型鏈繼承的優(yōu)點(diǎn)。但是執(zhí)行了兩次Person，屬性重復(fù)了。

function Person(name) {
    this.name = name;
    this.value = ["head", "body", "legs"];
}
Person.prototype.getName = function() {
    return this.name;
};

// 構(gòu)造函數(shù)繼承
function Teacher(name, school){
    // 執(zhí)行又一次Person
    Person.call(this, name);
    this.school = school;
}

// 原型鏈繼承
// 執(zhí)行一次Person
Teacher.prototype = new Person(); 
const Eric = new Teacher("Eric",27);
Eric.getName();
// 輸出：Eric



// prototype構(gòu)造器指回自己 
Teacher.prototype.constructor = Teacher;

Teacher.prototype.getSchool = function() {
    return this.school;
};

特點(diǎn)：既可以繼承實(shí)例屬性和方法，也可以繼承原型屬性和方法。既是子類的實(shí)例也是父類的實(shí)例，不存在引用屬性共享的問題。可以傳參，函數(shù)可復(fù)用。

缺點(diǎn)：調(diào)用兩次父類構(gòu)造函數(shù)，生成了兩份實(shí)例。

借助原型可以基于已有的對象創(chuàng)建新的對象，同時(shí)還不必因此創(chuàng)建自定義類型。

原理：（本質(zhì)）利用一個(gè)空對象作為一個(gè)中介。

const lakers = {
    name: "lakers",
    value: ["Micheal", "Wade", "Kobe"]
};

const lakers1 = Object.create(lakers);
const lakers2 = Object.create(lakers);

lakers1.value.push("Fish");
console.log(lakers);

模擬Object.create()

object.create()原理：用一個(gè)函數(shù)包裝一個(gè)對象，然后返回這個(gè)函數(shù)的調(diào)用，這個(gè)函數(shù)就變成了一個(gè)可以隨意添增屬性的實(shí)例或?qū)ο蟆?/p>

Object.prototype.create = function(obj) {
    function Fun() {}
    Fun.prototype = obj;
    return new Fun();
}

缺點(diǎn)有兩點(diǎn)：第一點(diǎn)是無法傳遞參數(shù)，第二點(diǎn)是引用類型存在變量的污染。

寄生式繼承的思路與寄生構(gòu)造函數(shù)和工廠模式類似，即創(chuàng)建一個(gè)僅用于封裝繼承過程的函數(shù)。

目的：在原型式繼承的基礎(chǔ)上，寄生增加了一些新的方法和屬性。

它的特點(diǎn)同原型式繼承一樣，也是無法傳遞參數(shù)，而且引用的數(shù)據(jù)類型也容易存在樣式污染。

Object.createNew()

Object.prototype.createNew = function(obj){
    var newObj = Object.create(obj);
    //獲取長度等于一個(gè)function
    newObj.getLength = function(){ ... };
    return newObj;
}

目的：為了解決數(shù)據(jù)重復(fù)拷貝兩遍的問題。

Super只執(zhí)行一次。

//定義Super構(gòu)造函數(shù)
function Super(name) {
  this.name = name;
  this.value = ["Hello", "Word"];
}
//在super的原型鏈添加一個(gè)getName
Super.prototype.getName = function() {
  return this.name;
};
//定義Sub
function Sub(name, age) {
  //調(diào)用構(gòu)造函數(shù)繼承
  Super.call(this, name);
  this.age = age;
}

let prototype = Object.create(Super.prototype);
prototype.constructor = Sub;
Sub.prototype = prototype;

Sub.prototype.getAge = function(){
  return this.age;
}

const instance1 = new Sub("Eric", 23);
const instance2 = new Sub("Vico", 23);
instance1.value.push("!");
instance2.value.push("!!");

借助原型式繼承Object.create拿到SuperClass，也就是父類，拿到父類的prototype之后把它賦給ClassOne，再然后我們將ClassTwo的prototype使用一個(gè)Object.assign，一個(gè)對象的拷貝，把它拷貝到ClassOne里面來，然后最后ClassOne.prototype.constructor等于ClassOne。

也就是使用一個(gè)Class.assign把所有我們想要繼承的父類的prototype全部組合到一起完成一個(gè)拷貝，之后再賦給對象。

function 

ClassOne.prototype = Object.create(SuperClass.prototype);

Object.assign(ClassOne.prototype, ClassTwo.prototype);

ClassOne.prototype.constructor = ClassOne;