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