JavaScript - 动态原型模式+寄生组合继承

Question

I am working through Professional JavaScript for Web Developers, and have a question regarding Object Creation and Inheritance. In the book, the Dynamic Prototype Pattern is discussed as a nice way of doing Combination Constructor/Prototype pattern while keeping the constructor and prototype encapsulated to the Object definition. Like this:

function Person(name, age, job) {
  this.name = name;
  this.age = age;
  this.job = job;

  if (typeof this.sayName != "function") {
    Person.prototype.sayName = function () {
      return this.name;
    };
  }
}

Of all the Object Creation patterns discussed in the book, I felt like this one looked the best. Then when discussing inheritance, the book says Parasitic Combination Inheritance is considered the optimal inheritance paradigm. As follows:

function inheritPrototype(subType, superType) {
  var prototype = Object.create(superType.prototype);
  prototype.constructor = subType;
  subType.prototype = prototype;
}

function SuperType(name) {
  this.name = name;
  this.colors = ['red', 'blue', 'green'];
}

SuperType.prototype.sayName = function() {
  return this.name;
};

function SubType(name, age) {
  SuperType.call(this, name);
  this.age = age;
}

inheritPrototype(SubType, SuperType);

SubType.prototype.sayAge = function() {
  return this.age;
}

As you can see, this code uses the Combination Constructor/Prototype Pattern for creating objects, where the prototypes are declared outside of the original object creation. My question is, is there any issue with combining the Dynamic Prototype Pattern with Parasitic Combination Inheritance, like this:

function inheritPrototype(subType, superType){
  var prototype = Object.create(superType.prototype);
  prototype.constructor = subType;
  subType.prototype = prototype;
}

function SuperType(name) {
  this.name = name;
  this.colors = ['red', 'blue', 'green'];

  if (typeof this.sayName != "function") {
    SuperType.prototype.sayName = function() {
        return this.name;
    };
  }
}

function SubType(name, age) {
  SuperType.call(this, name);
  this.age = age;

  if (typeof this.sayAge != "function") {
    SubType.prototype.sayAge = function() {
        return this.age;
    };
  }
}

inheritPrototype(SubType, SuperType);

I've tested this in a jsfiddle here and it seems to work fine, I just wanted to make sure there isn't something I'm missing that will cause problems later using this pattern/inheritance.

Also, as I know this book is a little older, are there new standards for object creation and inheritance?

Answer 1

Both approaches seem broken .

A given object prototype properties should be available even if the constructor function hasn't been called already. In the other hand, it seems like this breaks the single responsibility principle , because the constructor is responsible of defining the prototype while it should just initialize the object being constructed .

Just one question: how you would inherit a given object's prototype before the base object is ever constructed? :

var B = Object.create(A.prototype);

Wait! A.prototype won't contain expected properties unless some code calls new A() before!

// Ugly as hell!
new A();
var B = Object.create(A.prototype);

In summary, don't try to shortcut JavaScript: it's better to learn it and don't try to wrap inheritance with useless/pointless functions.

Actually, ECMA-Script 6 and above standards have already defined syntactic sugar to make JavaScript prototype chain look like classical inheritance:

class B extends A 
{
}

...which is absolutely equivalent to:

function B() {}
B.prototype = Object.create(A.prototype);