Si funksionon trashëgimia prototipale?

Question

Accepted Answer

Çdo objekt JavaScript ka një lidhje të fshehur me një objekt tjetër të quajtur **prototip** i tij. Kur aksesoni një pronësi, JS shikon në vetë objektin, pastaj ecën lart këtë **zinxhir prototipesh** derisa të gjejë pronësinë ose të arrijë në `null`. Ky është *delegim*, jo kopjim.

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

## Si përdorin klasat këtë

`class` është sheqer sintaksore mbi prototipet. Metodat jetojnë **një herë** në prototip, të ndara nga të gjitha instancat (jo të kopjuara për objekt):

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

Pra `d.speak` nuk ruhet në `d` — gjendet duke ecur lart tek `Dog.prototype`. Kjo është arsyeja pse të gjithë qenët ndajnë një funksion `speak` (efikase në memorie).

## Pse ka rëndësi

Përcaktimi i zinxhirit shpjegon: pse instancat ndajnë metoda, pse ndryshimi i një prototipje ndikon në të gjithë objektet e lidhur, si funksionon `instanceof` (kontrollon zinxhirin), dhe kostoja e zinxhireve të gjate të kërkimit.

Ç themelore nën `class`, funksioneve të integruar (`Array.prototype.map`), dhe trashëgimisë.