Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / JavaScript

Acceso a propiedades mediante una clave calculada

La notación con corchetes `obj[expr]` selecciona una propiedad según el valor de una expresión. Permite leer y escribir propiedades y llamar a métodos cuyas claves se determinan en tiempo de ejecución.

Versión: ECMAScript 2024 and the current web platform; runtime support varies

Sintaxis

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

En obj[expr], el valor de expr determina la clave de la propiedad. obj.key siempre usa la cadena "key", mientras que obj[key] usa el valor de la variable key. Los corchetes también admiten claves con espacios. En { [expr]: value } indican un nombre de propiedad calculado: se define una propiedad en un literal de objeto, en lugar de leerla de un objeto existente.

ToPropertyKey convierte el valor de la clave en un valor primitivo. Si es un Symbol, lo conserva; en caso contrario, lo convierte en una cadena. Por eso, obj[1] y obj["1"] se refieren a la misma propiedad. Convertir un objeto usado como clave puede ejecutar código y lanzar una excepción.

Una lectura ordinaria puede recorrer la cadena de prototipos e invocar un getter. Una propiedad ausente da undefined, pero una propiedad existente también puede dar undefined. Object.hasOwn(obj, key) comprueba si la propiedad es propia. obj[key] = value sigue las reglas normales de asignación, y una llamada directa obj[key]() tiene a obj como receptor, igual que obj.method().

Leer directamente de null o undefined lanza un TypeError. Con una base así, obj?.[expr] devuelve undefined sin evaluar expr; esta forma no puede ser el destino de una asignación. El acceso con corchetes es sintaxis de ECMAScript, no una API del navegador. Comprueba que el entorno de destino admita ?. y Object.hasOwn.

Los corchetes no validan las claves externas. Antes de leer o escribir a partir de datos no fiables, limita las claves a una lista explícita de valores permitidos. Object.hasOwn no comprueba por sí solo los permisos.

Ejemplos

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

Resultado

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

El ejemplo actualiza el valor de una clave con un espacio y muestra que `scores.key` busca la clave literal `"key"`. El último acceso omite `evaluations++`, por lo que el contador sigue en `0`.

Lecciones relacionadas

  • JavaScript · Lección 24 · Avanzado · Versión: 4
  • JavaScript · Lección 25 · Avanzado · Versión: 4
  • JavaScript · Lección 29 · Avanzado · Versión: 4

Fuentes