Prototypal inheritance inafanya kazi vipi?

Question

Accepted Answer

Kila kitu cha JavaScript kina kiungo cha kufichwa kwa kitu kingine kinachoitwa **prototype** yake. Wakati unafanya ufikiaji wa mali, JS inatafuta kwenye kitu lenyewe, kisha inakwenda juu ya **prototype chain** hii hadi itakapopata mali au kufikia `null`. Hii ni *delegation*, si kunakili.

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

## Jinsi klasi inavyoitumia

`class` ni syntactic sugar juu ya prototypes. Mbinu zinaishi **mara moja** kwenye prototype, zilizogawanywa na matukio yote (si kunakilisha kwa kila kitu):

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

Kwa hiyo `d.speak` haisimamii kwenye `d` — inapatikana kwa kwenda juu kwa `Dog.prototype`. Hiyo ndio sababu kila mbwa zinashiriki `speak` moja (inakuza kumbukumbu).

## Kwa nini umuhimu wake

Kuelewa chain inaeleza: kwa nini matukio yanashiriki mbinu, kwa nini kurekebisha prototype kuathiri vitu vyote vilivyounganishwa, jinsi `instanceof` inavyofanya kazi (inaangalia chain), na gharama ya minyororo ya maswali mirefu.

Ni msingi chini ya `class`, inayojengwa (`Array.prototype.map`), na urithi.