როგორ მუშაობს პროტოტიპული მემკვიდრეობა?

Question

Accepted Answer

ყველა JavaScript ობიექტს აქვს ფარული ბმული სხვა ობიექტზე, რომელსაც მის **პროტოტიპი** ეწოდება. როდესაც თქვენ ხვდებით თვისებას, JS ეძებს თვით ობიექტზე, შემდეგ მიდის ამ **პროტოტიპული ჯაჭვით** მანამ, სანამ არ იპოვის თვისებას ან არ ჩაწვდება `null`-ზე. ეს არის *დელეგირება*, არა კოპირება.

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

## როგორ იყენებთ კლასები

`class` არის სინტაქსური შაქრი პროტოტიპებზე. მეთოდები ცხოვრობენ **ერთხელ** პროტოტიპზე, რომელიც გაზიარებულია ყველა ინსტანციის მიერ (არა კოპირებული თითოეული ობიექტისთვის):

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

ამრიგად, `d.speak` არ ინახება `d`-ზე — ის გვხვდება `Dog.prototype`-ზე აყვანით. ამიტომ ყველა ძაღლი იზიარებს ერთ `speak` ფუნქციას (მეხსიერების შემნახველი).

## რატომ არის მნიშვნელოვანი

ჯაჭვის გაგება ხსნის: რატომ იზიარებენ ინსტანციები მეთოდებს, რატომ ზემოქმედებს პროტოტიპის ცვლილება ყველა დაკავშირებულ ობიექტზე, როგორ მუშაობს `instanceof` (ის ჯაჭვს შემოწმებს) და გრძელი საძებო ჯაჭვების ღირებულება.

ეს არის საფუძველი `class`-ის, built-ins-ის (`Array.prototype.map`) და მემკვიდრეობის ქვეშ.