JavaScript - Dynamisches Prototypmuster + Parasitäre Kombinationsvererbung

Question

Ich arbeite mit Professional JavaScript für Webentwickler und habe eine Frage bezüglich Objekterstellung und Vererbung. In diesem Buch wird das Dynamic Prototype Pattern als eine nette Methode zum Kombinieren von Konstruktor/Prototyp-Mustern diskutiert, während Konstruktor und Prototyp in der Objektdefinition gekapselt bleiben. Wie folgt aus:

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; 
    }; 
    } 
} 

Von allen Objekterstellung Muster in dem Buch besprochen, fühlte ich mich wie dieses am besten aussah. Wenn dann die Vererbung diskutiert wird, sagt das Buch, dass parasitische Kombinationsvererbung als das optimale Vererbungsparadigma angesehen wird. Wie folgt:

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; 
} 

Wie Sie sehen können, dieser Code die Kombination Constructor/Prototyp-Muster für die Erstellung von Objekten verwendet, wo die Prototypen außerhalb der ursprünglichen Objekterstellung deklariert sind. Meine Frage ist, gibt es eine Ausgabe mit dem dynamischen Prototyp-Muster mit Parasitäre Kombination Vererbung kombiniert, wie folgt aus:

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); 

ich dies in einem jsfiddle here getestet haben und es scheint gut zu funktionieren, ich wollte nur machen sicher, dass ich etwas nicht vermisse, das später Probleme mit diesem Muster/Vererbung verursachen wird.

Auch, wie ich weiß, dieses Buch ist ein wenig älter, gibt es neue Standards für die Erstellung und Vererbung von Objekten?

Answer 1

Beide Ansätze scheinen gebrochen.

Die Eigenschaften eines gegebenen Objektprototyps sollten auch dann verfügbar sein, wenn die Konstruktorfunktion noch nicht aufgerufen wurde. Auf der anderen Seite scheint es so zu sein, dass dies das Einzelverantwortlichkeitsprinzip bricht, da der Konstrukteur dafür verantwortlich ist, den Prototyp zu definieren, während er initialisieren sollte das zu konstruierende Objekt.

Nur eine Frage: , wie Sie ein bestimmtes Objekt Prototyp vor der Basisobjekt erben würde, wird jemals gebaut?:

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

Warten Sie! A.prototype enthält keine erwarteten Eigenschaften, es sei denn, ein Code ruft zuvor new A() auf!

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

Zusammengefasst nicht versuchen, JavaScript abzukürzen: es ist besser, es zu lernen und versuchen Sie nicht, Vererbung zu wickeln mit nutzlosen/sinnlos Funktionen.

Eigentlich ECMA-Script 6 und über Standards werden bereits syntaktischen Zucker machen JavaScript Prototypkette wie klassisches Erbe aussehen definiert:

class B extends A 
{ 
} 

..., die absolut gleichwertig ist:

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