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

CKTIS / JavaScript

Sintaxis abreviada de métodos en literales de objeto

La forma `method() {}` define un método directamente en un literal de objeto. La llamada determina `this`, pero `super` empieza la búsqueda en el prototipo del objeto donde se definió el método.

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

Sintaxis

const key = "computed";
({ method(a, b) { /* body */ } });
({ [key](a) { /* body */ } });
({ *generate() { /* body */ }, async run() { /* body */ }, async *stream() { /* body */ } });

En un literal de objeto, method(a) { … } define un método sin dos puntos ni la palabra clave function. Crea una propiedad de datos propia, modificable, enumerable y configurable. { method } es otra abreviatura: usa un vínculo existente como valor de la propiedad y no define una función nueva.

En obj.method(), this es obj. Extraer el método no lo vincula al objeto; si lo pasas como función de retorno de llamada y quieres conservar el receptor, usa obj.method.bind(obj). En cambio, una función flecha usada como valor de una propiedad toma this de su ámbito envolvente.

super.method() empieza a buscar en el prototipo actual del objeto donde se definió el método y pasa el mismo this al método invocado. Copiar el método a otro objeto no cambia ese punto de partida. Con method: function () { … } no se puede usar super directamente en el cuerpo de esa función. Una expresión de función ordinaria puede servir como constructor, pero new obj.method() lanza un TypeError si el método se definió con la sintaxis abreviada.

[key](a) { … } usa una clave calculada. *generate(), async run() y async *stream() definen, respectivamente, un método generador, uno asíncrono y uno generador asíncrono, cada uno con su propio cuerpo. Estas formas están especificadas en ECMAScript 2024; comprueba su compatibilidad en tu entorno de ejecución.

Ejemplos

(() => {
  const base = { read() { return this.value; } };
  const obj = {
    value: 2,
    read() { return super.read() + 1; },
    ordinary: function () {},
  };
  Object.setPrototypeOf(obj, base);
  const other = { value: 9, read: obj.read };

  console.log(obj.read());
  console.log(other.read());
  console.log(new obj.ordinary() instanceof obj.ordinary);
  try {
    new obj.read();
  } catch (error) {
    console.log(error.name);
  }
})();

Resultado

3
10
true
TypeError

Ambas llamadas encuentran `base.read` mediante `super`. La primera usa `obj` como `this` y da `3`; la segunda usa `other` y da `10`. `true` confirma que `ordinary` creó una instancia, mientras que `TypeError` muestra que el método abreviado `read` no es un constructor.

Lecciones relacionadas

  • JavaScript · Lección 41 · Avanzado · Versión: 4

Fuentes