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