Comment fonctionne l'héritage prototypal ?

Question

Accepted Answer

Chaque objet JavaScript possède un lien caché vers un autre objet appelé son **prototype**. Quand vous accédez à une propriété, JS la cherche d'abord sur l'objet lui-même, puis remonte la **prototype chain** (chaîne de prototypes) jusqu'à ce qu'il trouve la propriété ou atteigne `null`. C'est de la *délégation*, pas de la copie.

```js
const animal = {
  speak() { return `${this.name} makes a sound`; },
};

const dog = Object.create(animal); // dog's prototype IS animal
dog.name = "Rex";
dog.speak();                       // "Rex makes a sound" — found on the prototype

Object.getPrototypeOf(dog) === animal; // true
dog.hasOwnProperty("speak");           // false — it's inherited, not own
dog.hasOwnProperty("name");            // true
```

## Comment les classes l'utilisent

`class` est du sucre syntaxique sur les prototypes. Les méthodes vivent **une seule fois** sur le prototype, partagées par toutes les instances (pas copiées par objet) :

```js
class Dog {
  constructor(name) { this.name = name; }
  speak() { return `${this.name} barks`; } // on Dog.prototype
}
const d = new Dog("Rex");
Object.getPrototypeOf(d) === Dog.prototype; // true
```

Donc `d.speak` n'est pas stockée sur `d` — elle est trouvée en remontant jusqu'à `Dog.prototype`. C'est pourquoi tous les chiens partagent une seule fonction `speak` (efficace en mémoire).

## Pourquoi c'est important

Comprendre la chaîne explique : pourquoi les instances partagent des méthodes, pourquoi changer un prototype affecte tous les objets liés, comment `instanceof` fonctionne (il vérifie la chaîne), et le coût des longues chaînes de recherche.

C'est la base de `class`, des éléments natifs (`Array.prototype.map`) et de l'héritage.