Jak funguje prototypální dědičnost?

Question

Accepted Answer

Každý objekt v JavaScriptu má skrytý odkaz na další objekt nazývaný **prototype**. Když přistoupíte k vlastnosti, JS ji hledá nejdřív na samotném objektu, poté se pohybuje po **prototype chain** (řetězec prototypů), dokud vlastnost nenajde nebo nedosáhne `null`. Jedná se o *delegaci*, nikoli o kopírování.

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

## Jak ji třídy využívají

`class` je syntaktický cukr nad prototypy. Metody se nacházejí **jednou** na prototypu, sdíleny všemi instancemi (nejsou kopírovány pro každý 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
```

Takže `d.speak` není uložena na `d` — je nalezena procházením řetězce až k `Dog.prototype`. Proto všichni psi sdílejí jednu funkci `speak` (je to paměťově efektivní).

## Proč je to důležité

Pochopení řetězce vysvětluje: proč instance sdílejí metody, proč změna prototypu ovlivní všechny propojené objekty, jak funguje `instanceof` (kontroluje řetězec), a náklady dlouhých vyhledávacích řetězců.

Je to základ pod `class`, vestavěnými prvky (`Array.prototype.map`) a dědičností.