Hvordan fungerer prototypal arv?

Question

Accepted Answer

Ethvert JavaScript-objekt har et skjult link til et andet objekt kaldet dets **prototype**. Når du tilgår en egenskab, søger JS på objektet selv først, derefter går op ad **prototype chain** (prototypekæden), indtil den finder egenskaben eller når `null`. Dette er *delegation*, ikke kopiering.

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

## Hvordan klasser bruger det

`class` er syntakssukkerbeskrivelse over prototyper. Metoder lever **én gang** på prototypen, delt af alle instanser (ikke kopieret pr. objekt):

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

Så `d.speak` er ikke gemt på `d` — den findes ved at gå op til `Dog.prototype`. Derfor deler alle hunde en `speak`-funktion (hukommelseseffektiv).

## Hvorfor det betyder noget

At forstå kæden forklarer: hvorfor instanser deler metoder, hvorfor ændring af en prototype påvirker alle linkede objekter, hvordan `instanceof` fungerer (den kontrollerer kæden), og omkostningerne ved lange opslagskæder.

Det er grundlaget under `class`, built-ins (`Array.prototype.map`), og arv.