Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

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

Sources