प्रोटोटाइपल इनहेरिटेंस कसे काम करते?

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`, बिल्ट-इन्स (`Array.prototype.map`) आणि इनहेरिटेंस अंतर्गत पाया आहे.