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

推荐阅读