Jak działa dziedziczenie prototypowe?

Question

Accepted Answer

Każdy obiekt JavaScript ma ukryty link do innego obiektu zwanego jego **prototypem**. Gdy uzyskujesz dostęp do właściwości, JS wyszukuje ją na samym obiekcie, a następnie przechodzi w górę tego **łańcucha prototypów**, aż znajdzie właściwość lub dotrze do `null`. To jest *delegacja*, a nie kopiowanie.

```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 klasy go wykorzystują

`class` to cukier syntaktyczny nad prototypami. Metody żyją **raz** na prototypie, współdzielone przez wszystkie instancje (nie kopiowane na obiekt):

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

Więc `d.speak` nie jest przechowywane na `d` — znajduje się poprzez przejście w górę do `Dog.prototype`. Dlatego wszystkie psy dzielą jedną funkcję `speak` (wydajna pamięciowo).

## Dlaczego to ważne

Zrozumienie łańcucha wyjaśnia: dlaczego instancje dzielą metody, dlaczego zmiana prototypu wpływa na wszystkie powiązane obiekty, jak działa `instanceof` (sprawdza łańcuch), oraz koszt długich łańcuchów wyszukiwania.

To podstawa `class`, wbudowanych (`Array.prototype.map`) i dziedziczenia.