முன்மாதிரி பரம்பரை எவ்வாறு செயல்படுகிறது?

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` முன்மாதிரிகளின் மீது syntax சர்க்கரை. முறைகள் **ஒரு முறை** முன்மாதிரியில் வாழ்கின்றன, அனைத்து நிகழ்வுகளால் பகிரப்படுகின்றன (ப்রতிটি பொருளுக்கு நகல் செய்யப்படவில்லை):

```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`), மற்றும் பரம்பரை.