Hur fungerar prototypal arv?

Question

Accepted Answer

Varje JavaScript-objekt har en dold länk till ett annat objekt som kallas dess **prototyp**. När du får åtkomst till en egenskap, söker JS på själva objektet och går sedan upp denna **prototypkedja** tills den hittar egenskapen eller når `null`. Detta är *delegation*, inte 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
```

## Hur klasser använder det

`class` är syntaxsocker över prototyper. Metoder lever **en gång** på prototypen, delad av alla instanser (inte kopierad per 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` lagras inte på `d` — det hittas genom att gå upp till `Dog.prototype`. Det är därför alla hundar delar en `speak`-funktion (minneseffektivt).

## Varför det är viktigt

Att förstå kedjan förklarar: varför instanser delar metoder, varför ändringar av en prototyp påverkar alla länkade objekt, hur `instanceof` fungerar (den kontrollerar kedjan), och kostnaden för långa uppslagningskedjor.

Det är grunden under `class`, inbyggda funktioner (`Array.prototype.map`), och arv.