六种继承方式

一致对继承只了解了三种，
今天看了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);
console.log(cat.eat('fish'));
console.log(cat.sleep());
console.log(cat instanceof Animal); //true 
console.log(cat instanceof Cat); //true

新建一个cat的实例作为子类的原型对象，
缺点：由于cat的原型对象指向父类的实例，所以所有的子类的都共用同一个原型对象，就是新建的实例animal

构造函数继承：

function Cat(name){
  Animal.call(this);
  this.name = name || 'Tom';
}

// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // false
console.log(cat instanceof Cat); // true

可以实现多继承（call多个构造函数）
缺点：无法继承原型上的属性

组合继承
这个是方式1和2的结合，一方面使用call继承构造函数的属性，另一方面使用实例来继承原型链中的属性

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);
console.log(cat.sleep());
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); // true

解决了方式2的缺点
缺点：
①还是多个实例使用同一个原型
②构造函数里面的内容被复制了2次

原型式继承
这种方法是一种继承的方法，并没有使用严格意义上的构造函数，是借助原型可以基于已有的对象创建新对象，同时还不必因此常见自定义类型
就是平时用得多的object.create()去指定需要继承的对象，这样能继承到构造函数和原型上的属性,在vue源码里面都使用过这个方式进行继承(好像是吧)

var person = { 
 name: 'Jiang', 
 friends: ['Shelby', 'Court'] 
} 
var anotherPerson = Object.create(person) 
console.log(anotherPerson.friends) // ['Shelby', 'Court']

object.create()函数的第二个参数自定义一些属性，跟object.defineProperties()第二个参数格式一样。实现了继承。

var person = { 
 name: 'Jiang', 
 friends: ['Shelby', 'Court'] 
} 
var anotherPerson = Object.create(person，{
  name:{
      value:'xff'
  }
}) 
console.log(anotherPerson.name) //xff

寄生式继承
寄生式继承是和原型式继承一个思路，
寄生式继承的思路与寄生构造函数和工厂模式类似，即创建一个仅用于封装继承过程的函数。该函数在内部以某种方式来增强对象。最后返回对象。

function createAnother(o) { 
 var clone = Object.create(o) // 创建一个新对象 
 clone.sayHi = function() { // 添加方法 
 console.log('hi') 
 } 
 return clone // 返回这个对象 
} 
var person = { 
 name: 'Jiang'
} 
var anotherPeson = createAnother(person) 
anotherPeson.sayHi()

基于person返回了一个新对象anotherPeson，新对象不仅拥有了person的属性和方法，还有自己的sayHi方法。
在主要考虑对象而不是自定义类型和构造函数的情况下，这是一个有用的模式。

寄生组合式继承
这种继承方式对于构造函数继承来说是最推荐的一种方式
在前面说的组合模式(原型链+构造函数)中，继承的时候需要调用两次父类构造函数
一种构造函数和一种实例
这个时候我就在想，为什么要实例一个呢为什么不直接把子类的原型对象直接指向父类的原型对象呢，但是这种肯定是不行的，就共用了。所以正确的方式就是把父类的原型对象拷贝一份一模一样的对象，然后再把子类的原型执行这个新对象，再执行以下关联。完美啊！！！
引用官方的继承方式下的例子：
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Object/create

// Shape - 父类(superclass)
function Shape() {
  this.x = 0;
  this.y = 0;
}

// 父类的方法
Shape.prototype.move = function(x, y) {
  this.x += x;
  this.y += y;
  console.info('Shape moved.');
};

// Rectangle - 子类(subclass)
function Rectangle() {
  Shape.call(this); // call super constructor.
}

// 子类续承父类
Rectangle.prototype = Object.create(Shape.prototype);
Rectangle.prototype.constructor = Rectangle;

var rect = new Rectangle();

console.log('Is rect an instance of Rectangle?',
  rect instanceof Rectangle); // true
console.log('Is rect an instance of Shape?',
  rect instanceof Shape); // true
rect.move(1, 1); // Outputs, 'Shape moved.'

一方面使用构造函数去继承构造函数上的实例
另一方面创建 基于父构造函数的原型的新对象 来作为子类构造函数的原型对象

// 子类续承父类
Rectangle.prototype = Object.create(Shape.prototype);
Rectangle.prototype.constructor = Rectangle;

这样就完成了继承了，这个方式是最好的！
参考自：
https://www.cnblogs.com/humin/p/4556820.html
https://www.jb51.net/article/117159.htm