Hogyan működik a prototípusos öröklődés?

Question

Accepted Answer

Minden JavaScript objektumnak van egy rejtett hivatkozása egy másik objektumra, amelyet az **prototype** (prototípusa) nevezünk. Amikor egy tulajdonságot accelálsz, a JS először megnézi magát az objektumot, majd felfelé halad a **prototype chain** (prototípusláncon) keresztül, amíg meg nem találja a tulajdonságot vagy el nem éri a `null` értéket. Ez *delegáció*, nem másolás.

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

## Hogyan használják ezt az osztályok

A `class` szintaxis cukor a prototípusok fölött. A metódusok **egyszer** élnek a prototípuson, az összes példány által megosztva (nem másolódik objektumonként):

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

Tehát `d.speak` nincs a `d`-n tárolva — a `Dog.prototype` felé való járással található meg. Ezért az összes kutya egy `speak` függvényt oszt meg (memória-hatékony).

## Miért fontos

A lánc megértése elmagyarázza: miért osztják meg a példányok a metódusokat, miért befolyásolja a prototípus módosítása az összes csatolt objektumot, hogyan működik az `instanceof` (ellenőrzi a láncot), és a hosszú keresési láncok költsége.

Ez az alap a `class`, beépített (`Array.prototype.map`), és az öröklődés alatt.