Wie funktioniert prototypale Vererbung?

Question

Accepted Answer

Jedes JavaScript-Objekt hat einen versteckten Link zu einem anderen Objekt, das als sein **Prototype** bezeichnet wird. Wenn Sie auf eine Eigenschaft zugreifen, sucht JS zuerst am Objekt selbst, dann geht es die **Prototype Chain** hinauf, bis es die Eigenschaft findet oder `null` erreicht. Dies ist *Delegation*, nicht Kopieren.

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

## Wie Klassen es verwenden

`class` ist syntaktischer Zucker über Prototypen. Methoden existieren **einmal** auf dem Prototype, geteilt von allen Instanzen (nicht pro Objekt kopiert):

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

Also `d.speak` wird nicht auf `d` gespeichert — es wird gefunden, indem man bis zu `Dog.prototype` hinaufgeht. Deshalb teilen sich alle Hunde eine `speak`-Funktion (speichereffizient).

## Warum es wichtig ist

Die Kette verstehen erklärt: warum Instanzen Methoden teilen, warum das Ändern eines Prototyps alle verknüpften Objekte beeinflusst, wie `instanceof` funktioniert (es prüft die Kette), und die Kosten langer Lookup-Ketten.

Es ist die Grundlage unter `class`, eingebaute Funktionen (`Array.prototype.map`) und Vererbung.