Hoe werkt prototypal inheritance?

Question

Accepted Answer

Elk JavaScript-object heeft een verborgen link naar een ander object dat zijn **prototype** wordt genoemd. Als je een eigenschap benadert, zoekt JS op het object zelf, loopt dan omhoog door deze **prototype-keten** totdat het de eigenschap vindt of `null` bereikt. Dit is *delegatie*, geen kopiëren.

```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
```

## Hoe klasses het gebruiken

`class` is syntactische suiker over prototypes. Methoden leven **eenmaal** op het prototype, gedeeld door alle instanties (niet per object gekopieerd):

```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
```

Dus `d.speak` wordt niet opgeslagen op `d` — het wordt gevonden door omhoog naar `Dog.prototype` te lopen. Daarom delen alle honden één `speak`-functie (geheugenefficiënt).

## Waarom het belangrijk is

Begrip van de keten verklaart: waarom instanties methoden delen, waarom het wijzigen van een prototype alle gekoppelde objecten beïnvloedt, hoe `instanceof` werkt (het controleert de keten) en de kosten van lange opzoekketen.

Het is de basis onder `class`, built-ins (`Array.prototype.map`) en overerving.