这个和前两种继承方式又有什么不同呢？
需要仔细体会

function Vehicle() {
    this.engines = 1;
}

Vehicle.prototype.igintion = function() {
    console.log("Turning on my engine.");
};

Vehicle.prototype.drive = function() {
    this.igintion();
    console.log("Steering and moving forward!");
};

function Car() {
    var car = new Vehicle();

    car.wheels = 4;

    var vehDrive = car.drive;

    car.drive = function() {
        vehDrive.call(this);
        console.log("Rolling on " + this.wheels + " wheels!");
    };

    return car;
}

var myCar = new Car();

Object.toString();
Object.prototype.toString();

myCar.drive();

js组合继承和组合寄生继承

js设计之初是没有继承的概念的，如果要实现ES6中class A extends B的形式，需要借用prototype和Function.prototype.apply()方法或Function.prototype.call()方法。

• 原型链继承方式：B.prototype = A.prototype;,目的是继承父类方法
• 构造函数继承方式:A.apply(this, arguments),目的是继承父类成员变量

我们先看两个类

 // 父类
 var A = function(name){
     this.name = name;// 父类属性
 }
 // 父类方法
 A.prototype.setName = function(name){
    this.name = name
 }
 // 子类
 var B = function (){
     A.apply(this, arguments);// 继承属性
 }
 // 子类方法
 B.prototype.getName = function(){
     return this.name;
 }

我们的目的是实现子类A继承父类B的属性name和方法setName()，并且B自有的属性和方法不能丢失

1.组合继承

将原型链继承和构造函数继承两种方式结合，apply()方法改变父类的this指向，prototype继承父类成员方法

// 父类
var A = function (name) {
    this.name = name;
}
A.prototype.setName = function (name) {
    this.name = name;
}
// 子类
var B = function () {
    A.apply(this, arguments);// 将A的this指向B的this， 并且A接收B的构造函数参数
}
B.prototype = A.prototype;// 继承父类方法
B.prototype.constructor = B;// 子类构造函数被覆盖掉了，恢复回来
// 必须先写上面两行，才能给子类添加成员方法
B.prototype.getName = function () {
    return this.name;
}

// 测试
var b = new B('张三')
b.setName('老刘')
console.log('name=', b.getName())

优缺点分析

优点：

• 写法简单，可满足基本使用

缺点：

• 1.顺序不能错。只能现将子类prototype执行父类的prototype，在增加子类原型方法。一旦顺序反了就会丢失子类自己的方法
• 2.原型链上__proto__看不到父类，实际上只是把父类的属性和方法指向了子类，并不是真正的继承

2.组合继承 + 寄生继承

• 1.我们可以创建一个内部函数作为寄生母体var fun = function(){}，
• 2.让这个母体继承父类的原型fun.prototype = A.prototype，
• 3.再把寄生母体的contructor指向子类，fun.prototype.contructor = B
• 4.创建寄生对象var obj = new fun(),这个obj没有任何属性，可以认为是个空对象，此时它的__proto__已经指向了A
• 5.把子类B的原型链替换为上面常见的寄生对象obj，B.prototype = obj
• 6.寄生继承完成，结束

// 父类
 var A = function(name){
     this.name = name;// 父类属性
 }
 // 父类方法
 A.prototype.setName = function(name){
    this.name = name
 }
// 调用此方法进行继承
var _extends = function(sub, sup){
    // 寄生函数
    var fun = function(){ }
    fun.prototype = sup.prototype;// 原型链继承
    fun.prototype.contructor = sub;// contructor丢失，恢复

    sub.prototype = new fun();// 寄生函数创建的实例，里面只有原型链(__proto__)
}
// 子类
var B = function (){
    A.apply(this, arguments);// 继承属性
}
_extends(B, A);
 // 子类方法
 B.prototype.getName = function(){
     return this.name;
 }

 var b = new B('张三')
 b.setName('李思')
 console.log(b.getName())

优缺点分析

优点：

• 1.解决掉组合继承不是真正继承的毛病
• 2.继承后的原型链比较清晰易懂

缺点：

• 额外增加一个寄生函数，占用更多内存

参考资料

• TypeScript中的extends继承原理分析

ES5没有类，所以函数即是类，习惯类的首字母大写

基本类型：object、function、array、boolean、number、string（记忆：即6个基本数据类型，用function和array替换掉null、undefined）

明确一点：ES5，1、实例（new）可以继承父类原型方法以及父类私有属性。

2、寄生继承只做继承父类原型方法，不继承父类私有属性；

3、组合继承即继承父类原型方法和继承父类私有属性。

ES5继承从两方面讲：继承父类私有属性，继承父类原型方法

最终目的：创建实例A继承Student.prototype继承People.prototype，实例A继承学生类，学生类继承人类。即：A -> Student.prototype -> People.prototype

//父类（人类）：

function People(name){        this.name = name; //构造函数，提供私有属性       }

People.prototype.SayName = function (){        console.log(this.name);        }

//子类（学生类）：
function Student(){        this.number = number; //构造函数，提供私有属性       }

一、目的：继承父类原型方法

错误做法：

有些人的做法是：Student.prototype = new People()

这样子做不会报错，也确实能够继承到父类的原型（方法）。但仔细一看，有他的“尴尬之处”。

不好的点有：1、我只想Student子类继承People父类的原型（方法），但这么实例的话使得Student.prototype（学生原型链）变成People父类的一个实例了（父类的原型方法以及私有属性，变成了Student.prototype的公有属性，多继承了一个东西，即父类的私有属性）；

2、这样子做，使得People类“无缘无故”调用了一次（影响性能）；

正确做法（寄生继承）：

将Student.prototype = new People()换成以下写法

function fn(){

        let fun = function(){};

        fun.prototype=People.prototype;        //将People.prototype赋值给fun.prototype

        return new fun()

}

Student.prototype = fn();//这样子继承，fun是一个没有私有属性，只有人类的原型方法，是一个很干净的函数。即：达到了我们的目的，只继承父类的原型方法。

二、目的：继承父类私有属性

在学生类创建时进行

function Student(name,number){

        People.call(this,name);        //达成目的，继承父类私有属性

        this.number = number;

}

最后将目的一、目的二整合就成了组合继承

//父类（人类）：

function People(name){        this.name = name;        }

People.prototype.sayName = function (){        console.log(this.name);        }

//子类（学生类）：

function Student(name,number){

        People.call(this,name);         //达成目的，继承父类私有属性

        this.number = number;

}

function fn(){

        let fun = function(){};

        fun.prototype=People.prototype;        //将People.prototype赋值给fun.prototype

        return new fun()

}

Student.prototype = fn();

Student.prototype.sayNumber = function(){console.log(console.log(this.number))}//给Student原型添加方法，根据自己的需求决定是否添加。

实例化：let A = new Student()

这样子A实例就可访问sayName和sayNumber原型方法了。达到我们的最终目的。即：A -> Student.prototype -> People.prototype

如果ES5的继承你已经能够清楚，那么ES6的继承学习起来将很轻松

ES6有类的概念，即class，不再用function创建类

创建父类：class People{

        constructor(name){        this.name = name;        }//构造函数，提供私有属性（constructor）

        sayName(){console.log(this.name)}//原型方法，不再用prototype添加

}

ES6继承：创建子类继承子类：

class Student extends People{        //extends就相当于继承了父类的原型方法

        constructor(name,number){

                super(name);        this.number = number;        

                //super继承父类私有属性，相当于ES5中People.call(this,name);

        }

}

实例化：let oA = new Student('天才威',24)

Tip1：可以只写extends不写constructor，相当于没有私有属性。

Tip2：写了constructor，就必须写super，且需要写在自己的私有属性之前。否则报错

篇幅过长，如有所遗漏评论区友好交流！