Qu'est-ce que les prototypes en JavaScript ?

En JavaScript, les objets peuvent hériter de propriétés et de méthodes d'autres objets via le mécanisme de prototypes. Chaque objet en JavaScript possède une propriété interne cachée [[Prototype]], qui pointe vers un autre objet, son prototype. Lorsqu'on accède à une propriété ou méthode d'un objet, le moteur JavaScript la recherche d'abord dans l'objet lui-même. Si elle n'est pas trouvée, il consulte la propriété [[Prototype]] et cherche dans le prototype. Ce processus se répète le long de la chaîne de prototypes jusqu'à ce que la propriété soit trouvée ou que null soit atteint (fin de la chaîne).

Concepts principaux:

• Chaîne de prototypes: Séquence d'objets liés via la propriété [[Prototype]].
• Héritage: Les objets héritent des propriétés et méthodes de leurs prototypes.
• __proto__: Propriété historiquement utilisée (bien que non standardisée à l'origine) pour accéder à [[Prototype]]. Il est désormais recommandé d'utiliser Object.getPrototypeOf().
• prototype: Propriété du constructeur vers laquelle [[Prototype]] fait référence dans les instances créées avec ce constructeur.

Exemple avec constructeur et prototype:

// Constructeur
function Person(name, age) {
  this.name = name;
  this.age = age;
}

// Ajouter une méthode au prototype
Person.prototype.sayHello = function() {
  console.log("Bonjour, je m'appelle " + this.name);
};

// Créer une instance
const person1 = new Person("Alice", 30);

// Appeler la méthode du prototype
person1.sayHello(); // Résultat: Bonjour, je m'appelle Alice

// Accéder au prototype de l'instance
console.log(Object.getPrototypeOf(person1) === Person.prototype); // Résultat: true

Dans cet exemple:

• Person est une fonction constructeur.
• Person.prototype est l'objet qui sert de prototype à toutes les instances créées avec new Person().
• sayHello est une méthode ajoutée au prototype. Toutes les instances de Person héritent de cette méthode.
• Lorsqu'on appelle person1.sayHello(), le moteur JavaScript cherche sayHello dans person1. S'il ne le trouve pas, il consulte le [[Prototype]] de person1 (qui est égal à Person.prototype) et trouve la méthode là.

Les prototypes permettent une utilisation efficace de la mémoire, car les méthodes et propriétés communes sont stockées dans le prototype, plutôt que d'être dupliquées dans chaque instance d'objet.