Conas a oibríonn oidhreachta prótataipiciúil?

Question

Accepted Answer

Tá nasc folaithe ag gach réad JavaScript do réad eile ar a dtugtar a **prototype**. Nuair a rochtaineann tú ar thuairim, breathnaíonn JS ar an réad féin, ansin siúlann sé suas an **prototype chain** go dtí go bhfaigheann sé an tuairim nó go sroicheann sé `null`. Is é seo *ionadaíochta*, ní cóipeáil.

```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
```

## Conas a úsáideann ranganna é

Is siúcar comhréire a thairngíonn `class` ar phrótataipí. Maíonn modhanna **uair amháin** ar an prototype, arna roinnt ar fad na n-iontásc (ní cóipeáil in aghaidh an réada):

```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
```

Mar sin níl `d.speak` stóráilte ar `d` — aimsítear é trí shiúl suas go `Dog.prototype`. Sin an fáth go roinneann gach madra feidhm `speak` amháin (éifeachtúil ar an cuimhne).

## Cén fáth a bhíonn sé ann

Tuigint ar an slabhra a míníonn: cén fáth go roinneann iontásc modhanna, cén fáth go n-athraíonn prótataip a thionchar ar gach réad nasctha, conas a oibríonn `instanceof` (seiceálann sé an slabhra), agus an costas ar shlabhraí fadaithe cuardaigh.

Is an bunús a thíonn faoi `class`, tógtha-ins (`Array.prototype.map`), agus oidhreachta.