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

CKTIS / JavaScript

Sintaxis de definición de métodos en literales de objeto

Con `method(param) { ... }` se define un método sin `:` ni `function`. La llamada determina `this`, pero el lugar de definición fija dónde empieza la búsqueda de `super`.

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

Sintaxis

const obj = {
  method(param) {},
  [keyExpression](param) {},
  *generator() {},
  async fetchValue() {},
  async *streamValues() {},
  get value() { return this._value; },
  set value(next) { this._value = next; },
};

En un literal de objeto, method(param) { ... } crea una propiedad de datos propia cuyo valor es una función. La propiedad es escribible, enumerable y configurable. Sustituye el nombre por [keyExpression] para calcular la clave al crear el objeto. La clave resultante es una cadena o un símbolo.

Al llamar a un método generador (*method() { ... }), se obtiene un iterador generador. Un método asíncrono (async method() { ... }) devuelve una promesa (Promise) y un método generador asíncrono (async *method() { ... }) devuelve un iterador asíncrono. Todas estas formas admiten claves calculadas. En cambio, get value() { ... } y set value(next) { ... } definen accesores que se ejecutan al leer y al asignar la propiedad, respectivamente, sin llamar a value().

En obj.method(), this es obj. Leer la función no la vincula al objeto: si extraes el método y lo llamas como función independiente, no recibe el receptor original. Usa fn.call(obj) para proporcionarlo explícitamente. Una función flecha guardada en una propiedad toma this del ámbito que la rodea.

super.prop y super[key] empiezan la búsqueda en el prototipo actual del objeto donde se definió el método ([[HomeObject]]). Copiar la función a otro objeto no cambia ese punto de partida, aunque puede cambiar this. super.method() pasa el this actual a la función encontrada. La llamada al constructor super() no está permitida en un método de un literal de objeto.

method() { ... } no equivale del todo a method: function () { ... }. Usar new obj.method() con un método definido mediante la sintaxis concisa lanza un TypeError, mientras que una expresión function ordinaria, síncrona y no generadora puede usarse como constructor. Escribir super.prop directamente en el cuerpo de esa expresión function provoca un SyntaxError.

Ejemplos

{
  const key = 'describe';
  const base = {
    label() { return `base:${this.name}`; },
  };
  const original = {
    __proto__: base,
    name: 'A',
    [key]() { return super.label(); },
    regular: function () { this.value = 'ordinary'; },
  };
  const other = { name: 'B', describe: original.describe };

  console.log(original.describe());
  console.log(other.describe());
  try {
    new original.describe();
  } catch (error) {
    console.log(error.name);
  }
  console.log(new original.regular().value);
}

Resultado

base:A
base:B
TypeError
ordinary

`__proto__: base` establece el prototipo de `original` en el literal. Ambas llamadas encuentran `base.label` mediante `super`, pero `this.name` vale primero `A` y después `B`. `new` lanza un `TypeError` con `describe`; la función ordinaria `regular` construye un objeto cuyo `value` es `ordinary`.

Lecciones relacionadas

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

Fuentes