Prototypal inheritance कसरी काम गर्छ?

Question

Accepted Answer

प्रत्येक JavaScript object को अर्को object को साथ एक लुकेको लिङ्क हुन्छ जसलाई यसको **प्रोटोटाइप** भनिन्छ। जब तपाई property को पहुँच गर्नुहुन्छ, JS अब object मा खोज गर्छ, त्यसपछी यो **प्रोटोटाइप चेन** को माथि हिँड्छ जब सम्म यसले property पत्ता लगाउँछ वा `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` प्रोटोटाइपहरु मा सिन्ट्याक्स चिनीको हो। विधिहरु **एकचोटि** प्रोटोटाइपमा रहन्छन्, सबै instances द्वारा साझा गरिन्छ (प्रत्येक object को लागि प्रतिलिपि गरिएको छैन):

```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` फंक्शन साझा गर्छन् (मेमोरी-कुशल)।

## यो किन महत्वपूर्ण हो

चेन बुझ्न: किन instances विधिहरु साझा गर्छन्, किन prototype परिवर्तन सबै linked objects लाई प्रभावित गर्छ, कसरी `instanceof` काम गर्छ (यसले चेन जाँच गर्छ), र लामो lookup chains को लागत।

यो `class`, built-ins (`Array.prototype.map`), र inheritance को आधार हो।