Bagaimana prototypal inheritance berfungsi?

Question

Accepted Answer

Setiap objek JavaScript memiliki tautan tersembunyi ke objek lain yang disebut **prototipenya**. Ketika Anda mengakses properti, JS mencari pada objek itu sendiri, kemudian berjalan ke atas **rantai prototipe** sampai menemukan properti atau mencapai `null`. Ini adalah *delegasi*, bukan penyalinan.

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

## Cara kelas menggunakannya

`class` adalah pemanis sintaks atas prototipe. Metode hidup **sekali** pada prototipe, dibagikan oleh semua instansi (bukan disalin per objek):

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

Jadi `d.speak` tidak disimpan pada `d` — ditemukan dengan berjalan ke atas ke `Dog.prototype`. Itulah mengapa semua anjing berbagi satu fungsi `speak` (hemat memori).

## Mengapa ini penting

Memahami rantai menjelaskan: mengapa instansi berbagi metode, mengapa mengubah prototipe mempengaruhi semua objek yang tertaut, bagaimana `instanceof` bekerja (ia memeriksa rantai), dan biaya rantai pencarian yang panjang.

Ini adalah fondasi di bawah `class`, built-in (`Array.prototype.map`), dan pewarisan.