Kako deluje prototipna dediščina?

Question

Accepted Answer

Vsak JavaScript-objekt ima skrito povezavo do drugega objekta, imenovanega njegov **prototip**. Ko dostopate do lastnosti, JS išče na samem objektu, nato se pomika po tej **verigi prototipov** dokler ne najde lastnosti ali ne doseže `null`. To je *delegiranje*, ne kopiranje.

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

## Kako razredi to uporabljajo

`class` je sintaktični sladkor nad prototippi. Metode živijo **enkrat** na prototipу, deljene z vsemi primerki (ne kopirane na 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
```

Torej `d.speak` ni shranjen na `d` — najdemo ga z gibanjem navzgor do `Dog.prototype`. To je razlog, zakaj si vsi psi delijo eno funkcijo `speak` (učinkovito glede pomnilnika).

## Zakaj je to pomembno

Razumevanje verige pojasnjuje: zakaj si primerki delijo metode, zakaj sprememba prototipa vpliva na vse povezane objekte, kako deluje `instanceof` (preverja verigo), in stroški dolgih verig iskanja.

To je temelj pod `class`, vgrajenimi funkcijami (`Array.prototype.map`) in dediščino.