CKTIS / JavaScript
Function.prototype et l’affectation de méthodes au prototype
Distinguez le prototype de la fonction elle-même de celui de ses instances et partagez une même méthode entre ces instances.
Version : ECMAScript 2024 and the current web platform; runtime support varies
Syntaxe
Function.prototype
Object.getPrototypeOf(Constructor)
Constructor.prototype.method = function (arg) { /* method body */ };
const instance = new Constructor();
instance.method(arg);
Object.getPrototypeOf(instance)Function.prototype est l’objet natif dont une fonction ordinaire comme Counter hérite les méthodes call, apply et bind. Utilisez Object.getPrototypeOf(Counter) pour connaître le prototype de la fonction elle-même. En revanche, Counter.prototype est une propriété propre au constructeur : elle désigne l’objet que new Counter(...) utilise comme prototype de la nouvelle instance.
Counter.prototype.double = function () { return this.value * 2; }; stocke la fonction sur le prototype au lieu de la copier dans chaque instance. Lors de l’appel early.double(), JavaScript cherche d’abord une propriété propre double sur early, puis remonte la chaîne de prototypes. Même si la fonction est trouvée sur le prototype, this vaut early. Une fonction fléchée ne convient pas ici : elle reprend le this de la portée englobante.
Ajouter une méthode à l’objet prototype existant la rend aussi accessible aux instances déjà créées, sauf si une propriété propre la masque. À l’inverse, Counter.prototype = {} remplace l’objet utilisé lors des prochains appels à new Counter(...). Les instances existantes conservent leur lien vers l’ancien prototype.
Ajoutez les méthodes d’instance au prototype de votre propre constructeur, et non à Function.prototype. Modifier ce prototype natif peut aussi affecter d’autres fonctions qui en héritent.
Exemples
{
function Counter(value) {
this.value = value;
}
const early = new Counter(3);
Counter.prototype.double = function () {
return this.value * 2;
};
const late = new Counter(5);
console.log(Object.getPrototypeOf(Counter) === Function.prototype);
console.log(Object.getPrototypeOf(early) === Counter.prototype);
console.log(early.double === late.double);
console.log(late.double());
Counter.prototype = {};
console.log(early.double());
console.log(typeof (new Counter(7)).double);
}Résultat
true true true 10 6 undefined
`early` est créée avant l’ajout de la méthode, mais en hérite quand même. Après le remplacement du prototype, `early.double()` renvoie toujours `6`, tandis que `typeof` renvoie `"undefined"` pour `double` sur la nouvelle instance.
Leçons associées
- JavaScript · Leçon 38 · Intermédiaire · Version : 3