快速区分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