ప్రోటోటైపల్ ఆనुకూలం ఎలా పనిచేస్తుంది?

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`), మరియు వారసత్వం.