KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / JavaScript

Klassenconstructor en methodedefinities

Maak instanties met `new`, initialiseer hun toestand in `constructor` en onderscheid prototypemethoden van statische methoden en `super()` van `super.method()`.

Versie: ECMAScript 2024 and the current web platform; runtime support varies

Syntax

class Base {
  constructor(value) { this.value = value; }
  method() { return this.value; }
  static method() { return new Base(0); }
}

class Derived extends Base {
  constructor(value) { super(value); }
  method() { return super.method(); }
}

new C(...) voert de constructor van klasse C uit. In een basisklasse kan constructor(...) instantie-eigenschappen zoals this.value initialiseren. Een aanroep van C() zonder new geeft een TypeError. De speciale constructor is een gewone, niet-statische methode met de niet-berekende naam constructor. Twee van zulke definities geven een SyntaxError; ze vormen geen overload. Gebruik standaardparameters om verschillende argumentlijsten met één constructor af te handelen.

Als je de constructor weglaat, levert JavaScript een standaardconstructor: voor een basisklasse doet die niets extra's, en in een gebruikelijke afgeleide klasse geeft die de argumenten door aan de constructor van de bovenliggende klasse. Roep in een expliciete afgeleide constructor super(...) aan voordat je this gebruikt; te vroege toegang tot this geeft een ReferenceError. Een afgeleide constructor mag super(...) overslaan als hij expliciet een object teruggeeft zonder this te gebruiken.

Schrijf in de klassebody method(...) { ... } zonder function en zonder komma's tussen methoden. Een publieke instantiemethode staat op C.prototype en wordt gedeeld door de instanties; een eigenschap zoals this.value in het voorbeeld hoort bij één instantie. static method(...) { ... } definieert een methode op de klasse zelf: roep die aan met C.method(). Gewone publieke methoden met dezelfde naam op hetzelfde object vormen geen overload: de latere definitie vervangt de eerdere.

In obj.method() is this gelijk aan obj. Haal je de methode los en roep je haar aan als fn(), dan is this gelijk aan undefined, omdat de klassebody in strikte modus draait. Gebruik obj.method.bind(obj) om het ontvangende object te behouden. In een instantiemethode van een afgeleide klasse begint super.method() met zoeken bij het huidige prototype van het object waarop de methode is gedefinieerd (bijvoorbeeld Derived.prototype) en volgt van daaruit de prototypeketen. In de getoonde code begint de zoekactie bij Base.prototype, maar als je het prototype van Derived.prototype wijzigt, verandert dat beginpunt. super.method() roept de gevonden methode aan met de huidige this, niet de constructor. Dit is ECMAScript-syntaxis, geen DOM-API. Controleer de ondersteuning in je doelomgeving.

Voorbeelden

{
  class Counter {
    constructor(value = 0) {
      this.value = value;
    }

    add(amount) {
      this.value += amount;
      return this.value;
    }
  }

  class StepCounter extends Counter {
    constructor(value, step) {
      super(value);
      this.step = step;
    }

    static defaultStep() {
      return 2;
    }

    advance() {
      return super.add(this.step);
    }
  }

  const first = new StepCounter(10, StepCounter.defaultStep());
  const second = new StepCounter(10, 5);
  console.log(first.advance());
  console.log(second.value);
  console.log(first.advance === second.advance);
}

Resultaat

12
10
true

`super(value)` initialiseert de tellerwaarde en `super.add(this.step)` verhoogt de waarde van de eerste instantie naar `12`. De tweede blijft op `10`, en `true` laat zien dat beide dezelfde functie `advance` delen.

Gerelateerde lessen

  • JavaScript · Les 7 · Gevorderd · Versie: 4
  • JavaScript · Les 17 · Gevorderd · Versie: 4
  • JavaScript · Les 39 · Gemiddeld · Versie: 3

Bronnen