Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / JavaScript

Accesso alle proprietà tramite una chiave calcolata

La notazione con parentesi quadre `obj[expr]` seleziona una proprietà in base al valore di un’espressione. Consente di leggere e scrivere proprietà e chiamare metodi la cui chiave è determinata durante l’esecuzione.

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

Sintassi

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

In obj[expr], il valore di expr determina la chiave della proprietà. obj.key usa sempre la stringa "key", mentre obj[key] usa il valore della variabile key. Le parentesi quadre ammettono anche chiavi con spazi. In { [expr]: value } indicano un nome di proprietà calcolato: si definisce una proprietà in un letterale oggetto, anziché leggerla da un oggetto esistente.

ToPropertyKey converte il valore della chiave in un valore primitivo. Se è un Symbol, lo mantiene; altrimenti lo converte in una stringa. Perciò obj[1] e obj["1"] indicano la stessa proprietà. Convertire un oggetto usato come chiave può eseguire codice e generare un’eccezione.

Una lettura ordinaria può seguire la catena dei prototipi e invocare un getter. Una proprietà assente restituisce undefined, ma anche una proprietà esistente può restituirlo. Object.hasOwn(obj, key) verifica se la proprietà appartiene direttamente all’oggetto. obj[key] = value segue le normali regole di assegnazione e una chiamata diretta obj[key]() ha obj come ricevente, proprio come obj.method().

Leggere direttamente da null o undefined genera un TypeError. Con una base di questo tipo, obj?.[expr] restituisce undefined senza valutare expr; questa forma non può essere usata come destinazione di un’assegnazione. L’accesso con parentesi quadre è sintassi ECMAScript, non un’API del browser. Verifica che l’ambiente di destinazione supporti ?. e Object.hasOwn.

Le parentesi quadre non convalidano le chiavi esterne. Prima di leggere o scrivere in base a un input non attendibile, limita le chiavi a un elenco esplicito di valori consentiti. Object.hasOwn da solo non verifica le autorizzazioni.

Esempi

{
  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}`);
}

Risultato

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

L’esempio aggiorna il valore associato a una chiave con uno spazio e mostra che `scores.key` cerca la chiave letterale `"key"`. L’ultimo accesso salta `evaluations++`, quindi il contatore resta a `0`.

Lezioni correlate

  • JavaScript · Lezione 24 · Avanzato · Versione: 4
  • JavaScript · Lezione 25 · Avanzato · Versione: 4
  • JavaScript · Lezione 29 · Avanzato · Versione: 4

Fonti