Kako funkcionira prototipsko nasleđivanje?

Question

Accepted Answer

Svaki JavaScript objekat ima skrivenu vezu na drugi objekat koji se naziva njegovim **prototype**. Kada pristupite svojstvu, JS prvo pogledam sam objekat, zatim ide gore kroz **prototype chain** dok ne pronađe svojstvo ili dok ne dosegne `null`. Ovo je *delegacija*, 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 klase to koriste

`class` je sintaksno šećer preko prototipa. Metode žive **jednom** na prototipu, dijeljene s svim instancama (ne kopira se po objektu):

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

Zato `d.speak` nije pohranjen na `d` — pronalazi se hod gore do `Dog.prototype`. Zato svi psi dijele jednu `speak` funkciju (učinkovita za memoriju).

## Zašto je to važno

Razumijevanje lanca objašnjava: zašto instance dijele metode, zašto promjena prototipa utječe na sve povezane objekte, kako `instanceof` funkcionira (proverava lanac), i trošak dugih lanaca pretrage.

To je temelj ispod `class`, ugrađenih (`Array.prototype.map`), i nasleđivanja.