js组合模式和寄生组合模式的区别研究

tolerious 发布于2019-08-23 15:24 / 1043人阅读

摘要：组合模式继承结合了构造函数继承时可以为每个属性重新初始化，构造一个副本的优点，以及原型链继承时一次定义处处共享的优点。但令我百思不得其解的是，从上面给出的例子来看，组合继承并没有调用两次超类型构造函数。

最近在阅读《js权威指南》的继承这一章，对于组合模式和寄生组合模式的区别有点混淆，在多次重读以及尝试之后，得到一些心得。

组合模式继承

结合了构造函数继承时可以为每个属性重新初始化，构造一个副本的优点，以及原型链继承时一次定义处处共享的优点。

下面看具体的例子

/*js*/
function SuperType(name) {
    this.name = name
    this.color = ["red","blue","green"]
}
SuperType.prototype.getSuperName = function () { //在原型链上而不是构造函数里面添加方法，是为了进行方法复用
    console.log(this.name)
}
function SubType(name, age) {
    SuperType.call(this,name) //在子类构造函数里面调用父类构造函数，创建一个新的对象
    this.age = age
}
SubType.prototype.getSubAge = function () { //子类特有的方法
    console.log(this.age)
}
var instance1 = new SubType("Maria",24)
instance1.color.push("black")
console.log(instance1.color) //  ["red","blue","green","black"]
var instance2 = new SubType("Jack",33)
console.log(instance2.color) // ["red","blue","green"]

可以看到即使父类有引用对象，子类两个实例的对象之间也不会互相影响。

这个例子最大程度上地优化了代码，将方法放在原型链上，而通过子类构造函数里的SuperType.call()，为每个子类对象初始化了父类对象里面的属性，这些属性就变成了子类独享的。组合继承成为js最常用的继承模式。

但组合模式也不是没有缺点。它的缺点在于：

无论在什么情况下，都会调用两次超类型构造函数，一次是在创建子类型原型的时候，另一次是在子类型构造函数的内部。

但令我百思不得其解的是，从上面给出的例子来看，组合继承并没有调用两次超类型构造函数。当实例化SubType的时候有通过SuperType.call()调用一次过一次SuperType。同时，instance1和instance2都是SubType对象。那么，第二次调用从何而来？

其实，上面的例子是并不完整的。两个实例实际上只继承了超类型的属性，却没有继承超类型的方法。

我们在实例化SubType的时候，实际上就自动给实例化对象创建了一个新的原型对象，这个原型对象跟超类型的原型对象没有什么关系。所以SubType并没有继承getSuperName()方法。

下面为子类型继承父类型原型的例子：

/*js*/
function SuperType(name) {
    this.name = name
    this.color = ["red","blue","green"]
}
SuperType.prototype.getSuperName = function () {
      console.log(this.name)
}
function SubType(name, age) {
      SuperType.call(this,name)
      this.age = age
}
SubType.prototype = new SuperType()
SubType.prototype.constructor = SubType
SubType.prototype.getSubAge = function () {
console.log(this.age)
}
var instance1 = new SubType()
instance1.color.push("black")
console.log(instance1.color)
var instance2 = new SubType()
console.log(instance2.color)

在这个例子中，我们来看一下instance1的组成：

在第一次调用SuperType的时候，SubType.prototype会得到两个属性：color和name，它们也是SuperType的实例属性，不过现在位于SubType的原型上面。

在实例化SubType时调用了第二次SuperType,这个时候SubType实例对象多了两个name和color的属性，这两个属性属于实例属性，会覆盖掉在SubType原型对象的属性。

为了解决组合继承这种无论如何都会调用两次的问题，便可以引用寄生组合式继承。

寄生组合式继承

寄生组合式继承是在原型式继承的基础上做的。

原型式继承时道格拉斯·克罗克福德在2006年提出来的。主要目的是可以基于已有的对象创建新的对象，而不必因此创建自定义类型。

具体代码如下：

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

通过将o赋给F的原型，再返回一个原型为o的新对象。

而寄生组合式继承在此基础上的代码为：

  function inheritPrototype(superType,subType){
    var prototype = object(superType.prototype) // 首先返回了一个原型是superType的原型的新对象
    prototype.constructor = subType // prototype的constructor从superType变成subType
    subType.protoType = prototype // 将拥有指向SubType函数的constructor，以及superType对象属性的新对象，赋给subType的原型
  }
  function SuperType(name) {
    this.name = name
    this.color = ["red","blue","green"]
  }
  SuperType.prototype.getSuperName = function () {
    console.log(this.name)
  }
  function SubType(name, age) {
    SuperType.call(this,name)
    this.age = age
  }
  inheritPrototype(SuperType,SubType) //调用inheritPrototype方法替换子类的原型
  SubType.prototype.getSubAge = function () {
    console.log(this.age)
  }
  var instance1 = new SubType("Maria",24)
  instance1.color.push("black")
  console.log(instance1.color) //  ["red","blue","green","black"]
  var instance2 = new SubType("Jack",33)
  console.log(instance2.color) // ["red","blue","green"]

寄生组合式继承在组合继承的基础上做了改进，只需要调用一次inheritPrototype函数，就可以把SuperType对象的原型属性继承给SubType对象，同时SubType实例的原型对象依然指向SubType函数。

ECMAScript把object()做了改进，变成了Object.create()方法，所以inheritPrototype方法的第一行可以写成：

 var prototype = Object.create(SuperType.prototype)

对比组合模式和寄生组合模式：

组合模式：为每个属性重新初始化，构造一个副本。但是每次实例化都会调用两次SuperType，降低性能。

寄生组合模式：在组合模式的基础上，通过一次性将子对象的原型替换成父对象的原型，同时原型指向子对象。每次初始化对象就只调用一次SuperType。可以提升效率。

GPU云服务器云服务器组合模式模式识别和图像识别区别 js组合继承 js组合重复数据

文章版权归作者所有，未经允许请勿转载,若此文章存在违规行为，您可以联系管理员删除。

转载请注明本文地址：https://www.ucloud.cn/yun/102010.html

JavaScript面向对象---原型链继承

摘要：因为这造成了继承链的紊乱，因为的实例是由构造函数创建的，现在其属性却指向了为了避免这一现象，就必须在替换对象之后，为新的对象加上属性，使其指向原来的构造函数。这个函数接收两个参数子类型构造函数和超类型构造函数。最近一直在研究js面向对象，原型链继承是一个难点，下面是我对继承的理解以下文章借鉴自CSDN季诗筱的博客原型链继承的基本概念： ES中描述了原型链的概念，并将原型链作为实现...

vspiders 2019-08-20 13:33 评论0 收藏0
js面向对象及原型继承学习笔记。

摘要：将构造函数的作用域赋值给新的对象因此指向了这个新对象。以这种方式定义的构造函数是定义在对象在浏览器是对象中的。构造函数在不返回值的情况下，默认会返回新对象实例。在创建子类型的实例时，不能向超类型的构造函数中传递参数。创建对象虽然Object构造函数或对象字面量都可以用来创建单个对象，但是这些方式有明显的缺点：使用同一个接口创建很多对象，会产生大量的重复代码。为解决这个问题，人们开始...

CrazyCodes 2019-08-23 16:56 评论0 收藏0
js继承的理解

摘要：创建自定义的构造函数之后，其原型对象只会取得属性，其他方法都是从继承来的。优缺点寄生式继承在主要考虑对象而不是创建自定义类型和构造函数时，是十分有用的。原文链接：https://kongchenglc.coding.me... 1.原型链 js的继承机制不同于传统的面向对象语言，采用原型链实现继承，基本思想是利用原型让一个引用类型继承另一个引用类型的属性和方法。理解原型链必须先理...

BlackFlagBin 2019-08-20 16:34 评论0 收藏0
理解js对象

摘要：将构造函数的作用域赋值给新对象因此指向了新对象执行构造函数的代码为这个新对象添加属性返回对象最初是用来标识对象类型的。但提到检测对象类型，还是使用将构造函数当作函数构造函数与其他函数唯一区别。创建对象虽然Object构造函数与对象字面量都能创建单个对象，但这些方式都有明显的缺点：使用同一个接口创建很多对象，会产生大量重复代码。 var obj = {}; //对象字面量 va...

zhouzhou 2019-08-21 16:56 评论0 收藏0
《javascript高级程序设计》继承实现方式

摘要：寄生式继承的思路与寄生构造函数和工厂模式类似，即创建一个仅用于封装继承过程的函数，该函数在内部已某种方式来增强对象，最后再像真的是它做了所有工作一样返回对象。这篇本来应该是作为写JS 面向对象的前奏，只是作为《javascript高级程序设计》继承一章的笔记原型链 code 实现 function SuperType() { this.colors = [red,blu...

cppprimer 2019-08-20 18:28 评论0 收藏0