Child1.prototype = BaseClass.prototype;
Should be Child1.prototype = Object.create(BaseClass.prototype)
You don't want the prototype object to be the same, you want a new prototype object that inherits from BaseClass
Live-voorbeeld
Disclaimer: Object.create
is ES5, use the ES5-shim for legacy platform support.
Om u een grondiger voorbeeld te geven:
// Create base prototype
var Base = {
method: function() {
return this.things;
},
constructor: function (things) {
this.things = things;
}
};
// Link constructor and prototype
Base.constructor.prototype = Base;
// Create child prototype that inherits from Base
var Child = Object.create(Base);
// overwrite constructor
Child.constructor = function (things) {
things++;
Base.constructor.call(things);
}
// Link constructor and prototype
Child.constructor.prototype = Child;
// Swap prototype and constructor around to support new
ChildFactory = Child.constructor;
var c = new ChildFactory(41);
console.log(c.method());//42
Visueel:
var Base = {...}
hier maken we eenvoudig een object met methoden en eigenschappen. We willen een exemplaar van dit object kunnen maken. Dus Base
is een "klasse" en alle it's methoden en eigenschappen zijn toegankelijk vanuit de instanties (inclusief constructor
).
Base.constructor.prototype = Base;
U moet de "Constructorfunctie" koppelen, een functie die u kunt aanroepen met nieuw
, waarmee u een nieuw exemplaar van het object ConstructorFunction.prototype
samen met het prototype-object krijgt . Dit is eigenlijk een beetje lijm die je handmatig moet doen, omdat ES dit niet voor jou doet.
Als u dit bent vergeten, heeft de constructorfunctie (die X.constructor
is) geen eigenschap .prototype
om exemplaren van over te nemen.
var Child = Object.create (Base);
Maak een nieuw object waarvan [[Prototype]]
Base
is. Dit is in feite het begin van uw prototypeketen
Child -> ([[Prototype]] = Base) -> ([[Prototype]] = Object.prototype) -> null
Child.x = ...
Nu voegen we eigenschappen aan ons onderliggende object toe, die de methoden zijn die instanties van Kind zullen erven. In principe maken we een nieuw prototype-object waarvan we het erven. Alle instanties delen de methoden en delen ook de methoden in de prototypeketen (inclusief Base
).
ChildFactory = Child.constructor;
het nieuwe
sleutelwoord werkt alleen op constructor-functies en niet op prototype-objecten, dus we moeten in principe zeggen "verander onze prototype-objectvariabele naar de constructorfunctie-variabele"
Zelf vind ik bij het opbouwen van "klassen" de prototype-objecten heel prettig om direct aan te pakken en bij het maken van instanties vind ik de constructorfuncties aangenaam om mee om te gaan.
Now when we call var c = new Child(41);
Het zal de constructorfunctie oproepen die we hebben gedefinieerd die dingen
zullen verhogen, en dan de basisconstructor oproepen.
Merk op dat op dit punt de prototypeketen van c eruit ziet
c -> ([[Prototype]] = Child)
-> ([[Prototype]] = Base)
-> ([[Prototype]] = Object.prototype)
-> null