js继承，实现继承的几种方式

继承是javascript中一个重要的概念，实现继承有这几种常用的方式。

首先定义一个父类：

// 定义一个动物类
function Animal (name) {
  // 属性
  this.name = name || 'Animal';
  // 实例方法
  this.sleep = function(){
    console.log(this.name + '正在睡觉！');
  }
}
// 原型方法
Animal.prototype.eat = function(food) {
  console.log(this.name + '正在吃：' + food);
};

1. 原型链（常用）

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

核心：将父类作为子类的原型。

优点：

• 非常纯粹的继承关系，实例是子类的实例，也是父类的实例

• 简单

• 父类新增原型方法/原型属性，子类都能访问的到

缺点：

• 要想为子类新增属性和方法，必须要在new Animal()这样的语句之后执行，不能放到构造器中
• 无法实现多继承
• 不能向父类传参
• 原型对象的属性会被所有实例共享

2、 借用构造函数：

复制父类的实例给子类

//核心：使用父类的构造函数增强子类实例，等于是复制父类的实例属性给子类（没用到原型）
function Cat(name) {
	Animal.call(this);
	this.name = name || 'Tom';
}

var cat = new Cat();
console.log(cat.name);		//Tom
cat.sleep();		//Tom正在睡觉！
console.log(cat instanceof Animal);		//false
console.log(cat instanceof Cat);		//true

优点：

• 可以在子类的构造函数中向父类传递参数
• 可以实现多继承（call，apply方法）

缺点：

• 实例并不是父类的实例，只是子类的实例
• 只能继承父类的实例属性和方法，不能继承原型属性/方法
• 方法都在构造函数中声明，函数无法复用

3、原型式继承（实例继承）（常用）：

function Cat(name){
  var instance = new Animal();
  instance.name = name || 'Tom';
  return instance;
}

// 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); // false

优点：

• 不限制调用方式，不管是new 子类还是子类(),返回的对象具有相同的效果

缺点：

• 实例是父类的实例，不是子类的实例
• 不支持多继承

4、 组合继承：将原型链继承和构造函数组合在一起

核心：通过调用父类构造，继承父类的属性并保留传参的优点，然后通过将父类实例作为子类原型，实现函数复用

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

优点：

• 可传参
• 函数可复用
• 解决了引用类型值被共享的问题
• 可以继承原型，也可以继承属性和方法

缺点：

• 由于调用了两次父类，所以产生了两份实例

5、拷贝继承：

function Cat(name){
	var animal = new Animal();
	for(let i in animal) {
		Cat.prototype[i] = animal[i];
	}
	Cat.prototype.name = name || 'Tom';
}

var cat = new Cat();
console.log(cat.name);	//Tom
cat.sleep();	//Tom正在睡觉！
console.log(cat instanceof Animal); 	// false
console.log(cat instanceof Cat);	 // true

优点：

• 支持多继承

缺点：

• 效率极低，内存占用高（因为要拷贝父类的属性）
• 无法获取父类不可枚举的方法（for in不能访问到的）

6、寄生组合式继承：

通过寄生的方式来修复组合式继承的不足，完美的实现继承

//父类
function People(name,age){
  this.name = name || 'wangxiao'
  this.age = age || 27
}
//父类方法
People.prototype.eat = function(){
  return this.name + this.age + 'eat sleep'
}
//子类
function Woman(name,age){
  //继承父类属性
  People.call(this,name,age)
}
//继承父类方法
(function(){
  // 创建空类
  let Super = function(){};
  Super.prototype = People.prototype;
  //父类的实例作为子类的原型
  Woman.prototype = new Super();
})();
//修复构造函数指向问题
Woman.prototype.constructor = Woman;
let womanObj = new Woman();

优点：

• 近乎完美的解决方法

缺点：

• 比较复杂

es6继承：

//class 相当于es5中构造函数
//class中定义方法时，前后不能加function，全部定义在class的protopyte属性中
//class中定义的所有方法是不可枚举的
//class中只能定义方法，不能定义对象，变量等
//class和方法内默认都是严格模式
//es5中constructor为隐式属性
class People{
  constructor(name='wang',age='27'){
    this.name = name;
    this.age = age;
  }
  eat(){
    console.log(`${this.name} ${this.age} eat food`)
  }
}
//继承父类
class Woman extends People{ 
   constructor(name = 'ren',age = '27'){ 
     //继承父类属性
     super(name, age); 
   } 
    eat(){ 
     //继承父类方法
      super.eat() 
    } 
} 
let wonmanObj=new Woman('xiaoxiami'); 
wonmanObj.eat();

es5继承和es6继承的区别：
es5继承首先是在子类中创建自己的this指向，最后将方法添加到this中

Child.prototype=new Parent() || Parent.apply(this) || Parent.call(this)

es6继承是使用关键字先创建父类的实例对象this，最后在子类class中修改this。

class===es6的语法糖，其是还是利用原型链继承来实现的。