参考自：一篇文章理解JS继承——原型链/构造函数/组合/原型式/寄生式/寄生组合/Class extends
本文是对继承的自己理解、扩展，比参考链接稍微详细一些，可结合两者阅读

1.简单的js继承

1.1原型链继承

js对象在寻找一个属性是否存在时先从对象的本身找，找不到再找__proto__上是否继承得有，没有就继续在下一层的__proto__上找，直到原型链的顶端null

关于原型链的知识可参考：最详尽的 JS 原型与原型链终极详解，没有「可能是」。（一）

function Person(){
    this.name="Person"
}
Person.prototype.getName=function(){
    return this.name
}
function Student(){
    this.name="Student"
}
Student.prototype=new Person()
console.log(new Student())

image.png
image.png

总得来说就是一个function 有一个原型对象prototype。然后这个new function()生成的实例有一个__proto__指向这个原型对象prototype。prototype是储存需要共有的变量、方法。__proto__指向原型对象prototype以获取变量、方法。要实现原型链继承就是实现通过__proto__获取到父对象的prototype。

Student.prototype=new Person()

每一个实例都可以获取到父对象的prototype
Student.prototype=new Person()
Student.prototype.__proto__=Person.prototype
var student=new Student() student.__proto__=Student.prototype student.__proto__.__proto__=Person.prototype

1.2构造函数继承

function Person(){
    this.name="Person"
}
function Student(){
    Person.call(this)
}
console.log(new Student)

image.png
在Student构造函数的内部调用Person.call(this) 调用Person函数，this指向Student使赋值操作是对Student中的this.name赋值。
这种子函数内部调用父函数.call(this)的方式使得子函数的this可以复制父函数上的this。
组合继承与原型链继承的区别。
组合继承是调用了.call(this)执行了父函数。

function Person(){
    this.name="Person"
    this.obj={name:"Person"}
}
function Student(){
    Person.call(this)
}

以上代码的Person.call(this)等价于

function Student(){
    this.name="Person"
    this.obj={name:"Person"}
}

对于{name:"Person"}这样的引用类型也是执行了{}字面量新建一个对象的方式。所以在组合继承中（构造函数没有引用外部的引用类型进行赋值）Student的this.obj与Person的this.obj指向的不是同一个对象，相互之间没有干扰。

但是如果是下面这种情况，构造函数使用了外部的引用类型进行赋值到this的属性上

let obj={name:"Person"}
function Person(){
    this.name="Person"
    this.obj=obj
}
function Student(){
    Person.call(this)
}
console.log(new Student().obj=== new Person().obj)//true

那么Student的this.obj与Person的this.obj指向同一个对象

2.综合继承方式

2.1组合继承

以上两种继承方式可以得知，构造函数继承的优点就是可以复制一份父构造函数this上的属性，并且互不干扰（构造函数的属性不来自于函数外部的引用类型）
原型链继承的优点就是用过__proto__指向同一个prototype原型链对象，实现变量
、方法的共享。
在一般的面向对象语言中，大多都是方法父类、子类共享，变量不共享。所以组合继承集合原型链继承、构造函数继承的特点以实现方法共享、变量不共享。

function Person(){
    this.type="Person"
}
Person.prototype.getType=function () {
    return this.type
}

function Student(){
    Person.call(this)
    this.occupation="Student"
}
Student.prototype=new Person()
Student.constructor=Student
console.log(new Student())

image.png

2.2组合继承

在组合继承中会调用两次父构造函数，造成资源浪费

function Student(){
    Person.call(this)
    this.occupation="Student"
}
Student.prototype=new Person()

Person.call（this）调用了一次，new Person（）又调用了一次
new Person是为了获取一个__proto__指向Person.prototype的对象，所以Person上的this属性是不必要的。

function object(o){
  function F(){}
  F.prototype = o;
  return new F();
}

这个object函数就是实现返回一个__proto__指向传入的prototype的对象。new F()时，由于F为空所以不会浪费资源
Student.prototype=new Person()
Student.prototype=object(Person.prototype)

以下为寄生组合继承的完整实现

function object(o) {
    function F() {}
    F.prototype=o
    return new F()
}
function  Person()
{
    this.type="Person"
}
Person.prototype.getType=function () {
    return this.type
}
function Student() {
    Person.call(this)
    this.occupation="Student"
}
Student.prototype=object(Person.prototype)
Student.prototype.constructor=Student//纠正constructor
Student.prototype.getOccupation=function(){
    return this.occupation
}
console.log(new Student())

image.png