快速区分js的6种继承方式--实例篇

首先，咱们定义一个父类Animal，接下来用Cat类来实现对这个父类的继承

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. 原型链继承

核心：子类的原型对象等于父类的实例( 子类.prototype=new 父类() )

function Cat(){  

}  
Cat.prototype = new Animal();  //若是等于父类prototype，就会改变（指向一样的地方）  
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

优势：

• 很是纯粹的继承关系，实例是子类的实例，也是父类的实例
• 父类新增原型方法/原型属性，子类都能访问到
• 简单，易于实现

缺点：

• 没法实现多继承
  只能继承一个直接父类，由于prototype指向了该父类的实例，没法继承其余类原型链上的方法
• 来自原型对象的引用属性是全部实例共享的
• 建立子类实例时，没法向父类构造函数传参

2. 构造继承

核心：使用父类的构造函数来得到子类属性和方法，等因而复制父类的实例属性给子类（父类.call(this)）

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

优势：

• 解决了1中，子类实例共享父类引用属性的问题（不是prototype）
• 建立子类实例时，能够向父类传递参数
• 能够实现多继承（call多个父类对象） 缺点：
• 实例并非父类的实例，只是子类的实例
• 只能继承父类的实例属性和方法，不能继承原型属性/方法
• 没法实现函数复用，每一个子类都有父类实例函数的副本，影响性能

3. 原型式继承

核心：原型式继承的object方法本质上是对参数对象的一个浅复制。

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

let cat = object(person);
cat.name = "Bob";
anotherPerson.friends.push("Rob");

优势：父类方法能够复用
缺点：父类的引用属性会被全部子类实例共享，子类构建实例时不能向父类传递参数
ECMAScript 5 经过新增 Object.create()方法规范化了原型式继承。这个方法接收两个参数:一 个用做新对象原型的对象和(可选的)一个为新对象定义额外属性的对象。在传入一个参数的状况下， Object.create()与 object()方法的行为相同。 因此上文中代码能够转变为
let cat = Cat(Animal); => let cat = Object.create(Animal);

4. 拷贝继承

核心：子类.prototype.属性=new 父类().属性

function Cat(name){  
 var animal = new Animal();  
 for(var p in animal){  
 Cat.prototype[p] = animal[p];  
 }  
 Cat.prototype.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

优势：

• 支持多继承

缺点：

• 效率较低，内存占用高（由于要拷贝父类的属性）
• 没法获取父类不可枚举的方法，原型上的能够获取（不可枚举方法，不能使用for in 访问到:需手动设置enurable为false:Object.defineProperty() 和symbol() ） Object.keys()不能获取原型上的 Object.getOwnPropertyNames()原型上没法遍历，自身可枚举和不可枚举均可以遍历

5. 组合继承（原型，构造函数继承的组合）

核心：经过调用父类构造，继承父类的属性并保留传参的优势，而后经过将父类实例做为子类原型，实现函数复用(父类.call(this),子类.prototype=new 父类())

function Cat(name){  
 Animal.call(this);  
 this.name = name || 'Tom';  
}  
Cat.prototype = new Animal();  
   
// 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

优势:

• 能够继承实例属性/方法，也能够继承原型属性/方法（原型继承）
• 既是子类的实例，也是父类的实例（原型链）
• 不存在引用属性共享问题（构造函数继承）
• 可传参 （构造函数继承）
• 函数可复用（原型链继承）

缺点：

• 调用了两次父类构造函数，生成了两份实例（子类实例将子类原型上的那份屏蔽了）

6. 寄生组合继承

经过寄生方式，砍掉父类的实例属性，这样，在调用两次父类的构造的时候，就不会初始化两次实例方法/属性，避免的组合继承的缺点（父类.call(this).var Super=function(){},Super.prototype=父类.prototype,子类.prototype=new Super）

function Cat(name){  
 Animal.call(this);    //实例的方法和属性  
 this.name = name || 'Tom';  
}  
(function(){  
 // 建立一个没有实例方法的类  
 var Super = function(){};  
 Super.prototype = Animal.prototype;  
 //将实例做为子类的原型  
 Cat.prototype = new Super();  
})();  
   
// 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

优势：

• 完美

缺点：

• 实现较为复杂

补充： ES6继承

class 子类 extends 父类{constructor(){super()}}

class Cat extends Animal {  
 constructor(name,food){  
 //调用父类的constructor(name)  
 super(name);   
 this.food = food  
 }  
 eat(food){  
 //调用父类的方法  
 super.eat(food);   
 }  
}  
​  
// 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