પ્રોટોટાઇપલ ઇનહેરિટેન્સ કેવી રીતે કામ કરે છે?

Question

Accepted Answer

દરેક JavaScript ઑબ્જેક્ટ પાસે બીજા ઑબ્જેક્ટ તરફ એક છુપાયેલી લિંક હોય છે જેને તેનું **prototype** કહેવાય છે. જ્યારે તમે કોઈ પ્રોપર્ટી ઍક્સેસ કરો છો, તો JS પ્રથમ ઑબ્જેક્ટ પર જોય છે, પછી આ **prototype chain** અપ સુધી ચાલે છે જ્યાં સુધી તે પ્રોપર્ટી શોધી શકે અથવા `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`), અને ઇનહેરિટેન્સ હેઠળનો ভিত્તિ છે.