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

Question

Accepted Answer

प्रत्येक JavaScript ऑब्जेक्ट के पास दूसरे ऑब्जेक्ट के लिए एक छिपी हुई लिंक होती है जिसे इसका **prototype** कहा जाता है। जब आप किसी प्रॉपर्टी को एक्सेस करते हैं, तो JS पहले ऑब्जेक्ट को देखता है, फिर इस **prototype chain** के ऊपर चलता है जब तक कि वह प्रॉपर्टी नहीं मिल जाती या `null` तक पहुंच जाता है। यह *delegation* है, कॉपी करना नहीं।

```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`), और इनहेरिटेंस के तहत नींव है।