ਪ੍ਰੋਟੋਟਾਈਪਲ ਵਿਰਾਸਤ ਕਿਵੇਂ ਕੰਮ ਕਰਦੀ ਹੈ?

Question

Accepted Answer

ਹਰੇਕ JavaScript ਆਬਜੈਕਟ ਕੋਲ ਇਕ ਲੁਕਿਆ ਹੋਇਆ ਲਿੰਕ ਹੁੰਦਾ ਹੈ ਇਕ ਹੋਰ ਆਬਜੈਕਟ ਲਈ ਜਿਸਨੂੰ ਇਸਦਾ **prototype** ਕਿਹਾ ਜਾਂਦਾ ਹੈ। ਜਦੋਂ ਤੁਸੀਂ ਕੋਈ ਵਿਸ਼ੇਸ਼ਤਾ ਐਕਸੇਸ ਕਰਦੇ ਹੋ, JS ਆਬਜੈਕਟ ਸਿਖਰ ਤੇ ਲੱਭਦਾ ਹੈ, ਫਿਰ ਇਸ **prototype ਚੇਨ** ਨੂੰ ਚੜ੍ਹਦਾ ਹੈ ਜਦ ਤੱਕ ਇਹ ਵਿਸ਼ੇਸ਼ਤਾ ਲੱਭ ਜਾਂਦਾ ਹੈ ਜਾਂ `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`), ਅਤੇ ਵਿਰਾਸਤ ਦੇ ਅਧੀਨ ਬੁਨਿਆਦ ਹੈ।