KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / JavaScript

Array-indexering en toegang tot eigenschappen met berekende sleutels

Met vierkante haken selecteer je array-elementen en benader je objecteigenschappen via sleutels die tijdens de uitvoering worden berekend.

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

Syntax

obj[keyExpr]
obj.name
obj[keyExpr] = value
({ [keyExpr]: value })
arr[index]
arr.at(index)
Object.hasOwn(arr, index)

obj[keyExpr] evalueert de expressie tussen de vierkante haken en past ToPropertyKey toe. Dat levert een tekenreeks of Symbol als sleutel op. Met deze notatie kun je een waarde lezen of toewijzen. obj.key gebruikt daarentegen altijd de letterlijke sleutel "key" en leest de variabele key niet. In de objectliteral { [key]: value } berekenen de haken de naam van de eigenschap die wordt gedefinieerd, in plaats van een bestaande eigenschap te benaderen.

In een array selecteren arr[0] en arr["0"] hetzelfde eerste element. Array-indexen zijn tekenreeksen met de canonieke decimale weergave van gehele getallen van 0 tot en met 2 ** 32 - 2. Maak je een eigen element aan op een index gelijk aan of groter dan length, dan wordt length de index plus één en kunnen er gaten ontstaan. "01" is geen array-index; het toevoegen van die eigenschap verandert length niet.

Een ontbrekende index lezen veroorzaakt geen bereikfout: de zoekactie kan een overgeërfde eigenschap vinden. Ontbreekt de sleutel in de hele prototypeketen, dan krijg je undefined. Bij een gat ontbreekt de eigen eigenschap op die index. Object.hasOwn(arr, index) onderscheidt een gat van een eigen element met de waarde undefined. Toegang met vierkante haken op null of undefined veroorzaakt een TypeError.

arr[-1] zoekt de eigenschap "-1"; arr.at(-1) leest de laatste positie van een niet-lege array. at() geeft undefined terug als de berekende positie buiten het bereik ligt. Controleer of de doelomgeving at() en Object.hasOwn() ondersteunt. Controleer sleutels uit onbetrouwbare invoer vóór gebruik aan de hand van een lijst met toegestane sleutels.

Voorbeelden

{
  const arr = ["A"];
  arr[2] = undefined;
  arr[3] = "D";
  arr["01"] = "tag";
  const key = "score";
  const obj = { [key]: 7 };

  console.log(`${arr[0]} ${arr["0"]}`);
  console.log(`${arr.length} ${arr["01"]}`);
  console.log(`${arr[1]} ${arr[2]}`);
  console.log(`${Object.hasOwn(arr, 1)} ${Object.hasOwn(arr, 2)}`);
  console.log(`${arr[-1]} ${arr.at(-1)}`);
  console.log(`${obj[key]} ${obj.key}`);
}

Resultaat

A A
4 tag
undefined undefined
false true
undefined D
7 undefined

De indexen `1` en `2` leveren allebei `undefined` op, maar alleen op `2` staat een eigen element. De sleutel `"01"` verandert de lengte van `4` niet. De objectliteral definieert `score`, niet `key`.

Gerelateerde lessen

  • JavaScript · Les 27 · Gevorderd · Versie: 4

Bronnen