六种继承方式

一致对继承只了解了三种，
今天看了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