Como o prototypal inheritance funciona?

Question

Accepted Answer

Cada objeto JavaScript tem um link oculto para outro objeto chamado seu **prototype**. Quando você acessa uma propriedade, JS procura no objeto em si, depois percorre esta **cadeia de protótipos** até encontrar a propriedade ou chegar a `null`. Isso é *delegação*, não cópia.

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

## Como classes usam

`class` é açúcar sintático sobre protótipos. Métodos vivem **uma vez** no protótipo, compartilhados por todas as instâncias (não copiados por objeto):

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

Então `d.speak` não é armazenado em `d` — é encontrado caminhando até `Dog.prototype`. É por isso que todos os cachorros compartilham uma função `speak` (eficiente em memória).

## Por que isso importa

Entender a cadeia explica: por que instâncias compartilham métodos, por que alterar um protótipo afeta todos os objetos vinculados, como `instanceof` funciona (verifica a cadeia), e o custo de cadeias de pesquisa longas.

É a base sob `class`, built-ins (`Array.prototype.map`), e herança.