CKTIS / JavaScript
Syntaxis van klasseconstructors en methoden
Een constructor initialiseert het object dat `new` maakt. Instantiemethoden worden gedeeld via het prototype en statische methoden horen bij de klasse.
Versie: ECMAScript 2024 and the current web platform; runtime support varies
Syntax
class Base {
constructor(value) { this.value = value; }
read() { return this.value; }
static kind() { return "base"; }
}
class Derived extends Base {
constructor(value) { super(value); }
read() { return super.read(); }
}
const instance = new Derived(5);
instance.read();
Derived.kind();Schrijf in de body van class constructor(...) { ... } en method(...) { ... } zonder het sleutelwoord function en zonder komma’s tussen definities. new C(...) voert de constructor uit; C(...) aanroepen zonder new geeft een TypeError. Een tweede speciale constructor in dezelfde klasse geeft een SyntaxError en is geen overloading. Gebruik standaardparameters of conditionele logica in één constructor. static constructor() en ['constructor']() zijn gewone methoden, geen speciale constructors.
Een openbare instantiemethode staat op C.prototype en wordt gedeeld door instanties. Een openbare static-methode hoort bij C: roep die aan met C.method(), niet via een instantie. Bij obj.method() is obj de ontvanger en wordt die this. Het ophalen van de methode bindt de ontvanger niet: na const f = obj.method heeft this bij een losse aanroep van f() de waarde undefined.
Methodedefinities kunnen vormen aannemen als async method(), *method() en async *method(). De accessors get value() en set value(v) worden uitgevoerd bij het lezen en schrijven van de eigenschap, zonder aanroep met haakjes. Een instantieveld method = () => {} maakt voor elke instantie een aparte functie, geen gedeelde prototypemethode. Gewone openbare methoden met dezelfde naam op hetzelfde object worden niet overbelast op basis van hun parameterlijst: de laatste definitie vervangt de vorige.
Zonder expliciete constructor krijgt een basisklasse een lege standaardconstructor. De standaardconstructor van een afgeleide klasse geeft de argumenten door aan de constructor van de bovenliggende klasse als die met new kan worden gebruikt. Een klassedefinitie met extends null en zonder expliciete constructor is geldig, maar een instantie maken met new geeft een TypeError, omdat er geen constructor van een bovenliggende klasse is die de argumenten kan ontvangen. Roep in een expliciete afgeleide constructor super(...) aan vóór het gebruik van this, anders volgt een ReferenceError. Je kunt super(...) overslaan door expliciet een ander object terug te geven zonder this te gebruiken. super.method() begint daarentegen met zoeken bij het bovenliggende object in de prototypeketen en behoudt de huidige this.
Dit is syntaxis van de taal ECMAScript 2024, geen browser-API. Controleer welke afzonderlijke syntaxisvormen je doelomgeving ondersteunt.
Voorbeelden
{
class Counter {
constructor(value) {
this.value = value;
}
read() {
return this.value;
}
static kind() {
return "counter";
}
}
class StepCounter extends Counter {
constructor(value, step) {
super(value);
this.step = step;
}
read() {
return super.read() + this.step;
}
}
const a = new StepCounter(5, 2);
const b = new StepCounter(8, 3);
console.log(a.read());
console.log(b.read());
console.log(a.read === b.read);
console.log(StepCounter.kind());
}Resultaat
7 11 true counter
`super(value)` initialiseert `value` en `read()` telt `step` op bij het resultaat van de basismethode. `true` bevestigt dat beide instanties dezelfde functie `read` delen. `StepCounter.kind()` roept de geërfde statische methode aan.
Gerelateerde lessen
- JavaScript · Les 26 · Gevorderd · Versie: 4