Come funziona l'ereditarietà prototipale?

Question

IT Interview Practice · Accepted Answer

Ogni oggetto JavaScript ha un collegamento nascosto a un altro oggetto chiamato il suo **prototype**. Quando accedi a una proprietà, JS guarda l'oggetto stesso, quindi risale la **prototype chain** finché non trova la proprietà o raggiunge `null`. Questo è *delega*, non copia.

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

## Come le classi lo usano

`class` è zucchero sintattico rispetto ai prototipi. I metodi vivono **una volta** sul prototipo, condivisi da tutte le istanze (non copiati per oggetto):

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

Quindi `d.speak` non è archiviato su `d` — viene trovato risalendo a `Dog.prototype`. È per questo che tutti i cani condividono una funzione `speak` (efficiente in memoria).

## Perché è importante

Comprendere la catena spiega: perché le istanze condividono metodi, perché modificare un prototipo influisce su tutti gli oggetti collegati, come funziona `instanceof` (controlla la catena), e il costo di lunghe catene di ricerca.

È la base sotto `class`, built-in (`Array.prototype.map`), e l'ereditarietà.

Come le classi lo usano

Perché è importante

Domande correlate