KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / JavaScript

Syntaxis voor methodedefinities in objectliteralen

Met `method(param) { ... }` definieer je een methode zonder `:` of `function`. De aanroep bepaalt `this`, maar de definitie bepaalt waar `super` begint te zoeken.

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

Syntax

const obj = {
  method(param) {},
  [keyExpression](param) {},
  *generator() {},
  async fetchValue() {},
  async *streamValues() {},
  get value() { return this._value; },
  set value(next) { this._value = next; },
};

In een objectliteraal maakt method(param) { ... } een eigen data-eigenschap met een functie als waarde. De eigenschap is schrijfbaar, opsombaar en configureerbaar. Gebruik [keyExpression] in plaats van de naam om de sleutel te berekenen wanneer het object wordt gemaakt. De resulterende sleutel is een tekenreeks of een symbool.

Een aanroep van een generatormethode (*method() { ... }) geeft een generatoriterator terug. Een asynchrone methode (async method() { ... }) geeft een Promise terug en een asynchrone generatormethode (async *method() { ... }) een asynchrone iterator. Al deze vormen ondersteunen berekende sleutels. get value() { ... } en set value(next) { ... } definiëren daarentegen accessors die bij het lezen respectievelijk toewijzen van de eigenschap worden uitgevoerd, zonder aanroep van value().

In obj.method() is this gelijk aan obj. Het uitlezen van de functie bindt die niet aan het object: als je de methode loshaalt en als zelfstandige functie aanroept, krijgt ze het oorspronkelijke ontvangende object niet mee. Geef het expliciet door met fn.call(obj). Een pijlfunctie die in een eigenschap is opgeslagen, neemt this juist over uit haar omringende scope.

super.prop en super[key] beginnen te zoeken bij het huidige prototype van het object waarin de methode is gedefinieerd ([[HomeObject]]). Kopieer je de functie naar een ander object, dan blijft dat startpunt hetzelfde, ook als this verandert. super.method() geeft de huidige this door aan de gevonden functie. De constructoraanroep super() is niet toegestaan in een methode van een objectliteraal.

method() { ... } is niet helemaal gelijkwaardig aan method: function () { ... }. Met de beknopte methodesyntaxis veroorzaakt new obj.method() een TypeError, terwijl een gewone synchrone function-expressie die geen generator is als constructor kan dienen. super.prop rechtstreeks in het functielichaam van zo’n function-expressie schrijven veroorzaakt een SyntaxError.

Voorbeelden

{
  const key = 'describe';
  const base = {
    label() { return `base:${this.name}`; },
  };
  const original = {
    __proto__: base,
    name: 'A',
    [key]() { return super.label(); },
    regular: function () { this.value = 'ordinary'; },
  };
  const other = { name: 'B', describe: original.describe };

  console.log(original.describe());
  console.log(other.describe());
  try {
    new original.describe();
  } catch (error) {
    console.log(error.name);
  }
  console.log(new original.regular().value);
}

Resultaat

base:A
base:B
TypeError
ordinary

`__proto__: base` stelt in het literaal het prototype van `original` in. Beide aanroepen vinden `base.label` via `super`, maar `this.name` is eerst `A` en daarna `B`. `new` veroorzaakt een `TypeError` bij `describe`; de gewone functie `regular` construeert een object waarvan `value` gelijk is aan `ordinary`.

Gerelateerde lessen

  • JavaScript · Les 20 · Gevorderd · Versie: 4

Bronnen