CKTIS / JavaScript
Syntaxe de définition des méthodes dans les littéraux d’objet
La forme `method(param) { ... }` définit une méthode sans `:` ni `function`. L’appel détermine `this`, tandis que le lieu de définition fixe le point de départ de `super`.
Version : ECMAScript 2024 and the current web platform; runtime support varies
Syntaxe
const obj = {
method(param) {},
[keyExpression](param) {},
*generator() {},
async fetchValue() {},
async *streamValues() {},
get value() { return this._value; },
set value(next) { this._value = next; },
};Dans un littéral d’objet, method(param) { ... } crée une propriété de données propre dont la valeur est une fonction. Cette propriété est modifiable, énumérable et configurable. Pour calculer la clé à la création de l’objet, remplacez le nom par [keyExpression]. La clé obtenue est une chaîne ou un symbole.
L’appel d’une méthode génératrice (*method() { ... }) renvoie un itérateur générateur. Une méthode asynchrone (async method() { ... }) renvoie une promesse (Promise), et une méthode génératrice asynchrone (async *method() { ... }) renvoie un itérateur asynchrone. Ces formes acceptent toutes des clés calculées. En revanche, get value() { ... } et set value(next) { ... } définissent des accesseurs exécutés respectivement à la lecture et à l’affectation de la propriété, sans appeler value().
Dans obj.method(), this vaut obj. Lire la fonction ne la lie pas à l’objet : si vous extrayez la méthode et l’appelez comme une fonction ordinaire, le récepteur d’origine ne lui est pas transmis. Utilisez fn.call(obj) pour le fournir explicitement. Une fonction fléchée stockée dans une propriété prend au contraire son this dans la portée englobante.
super.prop et super[key] commencent la recherche dans le prototype actuel de l’objet où la méthode a été définie ([[HomeObject]]). Copier la fonction vers un autre objet ne change pas ce point de départ, même si this peut changer. super.method() transmet le this courant à la fonction trouvée. L’appel de constructeur super() n’est pas autorisé dans une méthode de littéral d’objet.
method() { ... } n’est pas tout à fait équivalent à method: function () { ... }. new obj.method() lève une TypeError avec une méthode définie par la syntaxe concise, alors qu’une expression function ordinaire, synchrone et non génératrice, peut servir de constructeur. Écrire super.prop directement dans le corps d’une telle expression function provoque une SyntaxError.
Exemples
{
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);
}Résultat
base:A base:B TypeError ordinary
Dans le littéral, `__proto__: base` fixe le prototype de `original`. Les deux appels trouvent `base.label` via `super`, mais `this.name` vaut d’abord `A`, puis `B`. `new` lève une `TypeError` avec `describe` ; la fonction ordinaire `regular` construit un objet dont la propriété `value` vaut `ordinary`.
Leçons associées
- JavaScript · Leçon 20 · Avancé · Version : 4