Cum funcționează moștenirea prototipală?

Question

Accepted Answer

Fiecare obiect JavaScript are o legătură ascunsă cu un alt obiect numit **prototipul** lui. Când accesați o proprietate, JS caută pe obiectul în sine, apoi parcurge această **lanț de prototipuri** până când găsește proprietatea sau ajunge la `null`. Aceasta este *delegare*, nu copiere.

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

## Cum clasele o folosesc

`class` este zaharificare sintactică peste prototipuri. Metodele trăiesc **o dată** pe prototip, partajate de toate instanțele (nu copiate per obiect):

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

Deci `d.speak` nu este stocat pe `d` — se găsește prin parcurgerea până la `Dog.prototype`. Acesta este motivul pentru care toți câinii partajează o funcție `speak` (eficient din punct de vedere al memoriei).

## De ce este important

Înțelegerea lanțului explică: de ce instanțele partajează metode, de ce modificarea unui prototip afectează toate obiectele legate, cum funcționează `instanceof` (verifică lanțul), și costul lanțurilor de căutare lungi.

Este baza sub `class`, built-in-uri (`Array.prototype.map`), și moștenire.