Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / JavaScript

Indexação de arrays e acesso a propriedades por chaves calculadas

Os parênteses retos permitem selecionar elementos de um array e aceder a propriedades de um objeto com chaves calculadas durante a execução.

Versão: ECMAScript 2024 and the current web platform; runtime support varies

Sintaxe

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

obj[keyExpr] avalia a expressão entre parênteses retos e aplica ToPropertyKey para obter uma chave do tipo cadeia de caracteres ou Symbol. Esta notação permite ler ou atribuir um valor. Já obj.key usa sempre a chave literal "key", sem ler a variável key. No literal { [key]: value }, os parênteses calculam o nome da propriedade a definir, em vez de acederem a uma propriedade existente.

Num array, arr[0] e arr["0"] selecionam o mesmo primeiro elemento. Os índices são cadeias de caracteres que representam, na forma decimal canónica, os inteiros de 0 a 2 ** 32 - 2. Criar um elemento próprio num índice igual ou superior a length aumenta length para o índice mais um e pode deixar lacunas. "01" não é um índice do array: adicionar essa propriedade não altera length.

Ler um índice em falta não causa um erro de limites: a pesquisa pode encontrar uma propriedade herdada, ou devolver undefined se a chave não existir em toda a cadeia de protótipos. Uma lacuna é a ausência de uma propriedade própria nesse índice. Object.hasOwn(arr, index) distingue uma lacuna de um elemento próprio com valor undefined. O acesso com parênteses retos sobre null ou undefined lança um TypeError.

arr[-1] procura a propriedade "-1"; arr.at(-1) lê a última posição de um array não vazio. at() devolve undefined se a posição calculada estiver fora dos limites. Confirma se o ambiente de execução de destino suporta at() e Object.hasOwn(). Antes de aceder a propriedades com chaves provenientes de dados não fiáveis, verifica se constam de uma lista de chaves permitidas.

Exemplos

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

Resultado

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

A leitura dos índices `1` e `2` devolve `undefined`, mas só no índice `2` existe um elemento próprio. A chave `"01"` não altera o comprimento de `4`. O literal define `score`, não `key`.

Lições relacionadas

  • JavaScript · Lição 27 · Avançado · Versão: 4

Fontes