KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / JavaScript

Eigenschapstoegang met een berekende sleutel

Met de blokhaaknotatie `obj[expr]` kies je een eigenschap op basis van een expressiewaarde. Zo kun je eigenschappen lezen en schrijven of methoden aanroepen waarvan de sleutel pas tijdens de uitvoering wordt bepaald.

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

Syntax

object[expression]
object[expression] = value
object[expression](...args)
object?.[expression]

In obj[expr] bepaalt de waarde van expr de eigenschapssleutel. obj.key gebruikt altijd de tekenreeks "key", terwijl obj[key] de waarde van de variabele key gebruikt. Met blokhaken kun je ook sleutels met spaties gebruiken. In { [expr]: value } geven ze een berekende eigenschapsnaam aan: je definieert een eigenschap in een objectliteral in plaats van die op een bestaand object te lezen.

ToPropertyKey zet de sleutelwaarde om in een primitieve waarde. Een Symbol blijft behouden; elke andere waarde wordt een tekenreeks. Daarom verwijzen obj[1] en obj["1"] naar dezelfde eigenschap. Bij het omzetten van een object dat als sleutel dient, kan code worden uitgevoerd en een uitzondering optreden.

Bij een gewone leesbewerking kan JavaScript de prototypeketen volgen en een getter aanroepen. Een ontbrekende eigenschap levert undefined op, maar een bestaande eigenschap kan dat ook doen. Object.hasOwn(obj, key) test of het om een eigen eigenschap gaat. obj[key] = value volgt de normale toewijzingsregels. Bij een directe aanroep obj[key]() is obj de ontvanger, net als bij obj.method().

Rechtstreeks lezen van null of undefined veroorzaakt een TypeError. Met zo’n basiswaarde levert obj?.[expr] undefined op zonder expr te evalueren; deze vorm is geen geldig toewijzingsdoel. Toegang met blokhaken is ECMAScript-syntaxis, geen browser-API. Controleer of je doelomgeving ?. en Object.hasOwn ondersteunt.

Blokhaken valideren geen externe sleutels. Beperk bij onbetrouwbare invoer de sleutels vóór het lezen of schrijven tot een expliciete lijst met toegestane waarden. Object.hasOwn controleert op zichzelf geen toegangsrechten.

Voorbeelden

{
  const key = "total points";
  const token = Symbol("bonus");
  const scores = { [key]: 7, [token]: 2, "1": "first" };

  console.log(`before: ${scores[key]}`);
  scores[key] = 9;
  console.log(`after: ${scores[key]}`);
  console.log(`literal key: ${scores.key}`);
  console.log(`symbol key: ${scores[token]}`);
  console.log(`numeric key: ${scores[1]}`);

  let evaluations = 0;
  const missing = null;
  console.log(`optional: ${missing?.[evaluations++]}`);
  console.log(`evaluations: ${evaluations}`);
}

Resultaat

before: 7
after: 9
literal key: undefined
symbol key: 2
numeric key: first
optional: undefined
evaluations: 0

Het voorbeeld wijzigt de waarde bij een sleutel met een spatie en laat zien dat `scores.key` de letterlijke sleutel `"key"` zoekt. De laatste toegang slaat `evaluations++` over, waardoor de teller op `0` blijft.

Gerelateerde lessen

  • JavaScript · Les 24 · Gevorderd · Versie: 4
  • JavaScript · Les 25 · Gevorderd · Versie: 4
  • JavaScript · Les 29 · Gevorderd · Versie: 4

Bronnen