Kế thừa nguyên mẫu (prototypal inheritance) hoạt động như thế nào?

Question

Accepted Answer

Mỗi object trong JavaScript có một liên kết ẩn đến một object khác gọi là **prototype** của nó. Khi bạn truy cập một thuộc tính, JS tìm trên chính object đó, rồi đi ngược lên **prototype chain** này cho đến khi tìm thấy thuộc tính hoặc đến `null`. Đây là *ủy quyền (delegation)*, không phải sao chép.

```js
const animal = {
  speak() { return `${this.name} makes a sound`; },
};

const dog = Object.create(animal); // prototype của dog LÀ animal
dog.name = "Rex";
dog.speak();                       // "Rex makes a sound" — tìm thấy trên prototype

Object.getPrototypeOf(dog) === animal; // true
dog.hasOwnProperty("speak");           // false — nó được kế thừa, không phải của riêng
dog.hasOwnProperty("name");            // true
```

## Cách các class sử dụng nó

`class` là cú pháp đường (syntax sugar) trên nền prototype. Các method tồn tại **một lần** trên prototype, được chia sẻ bởi tất cả các instance (không sao chép cho từng object):

```js
class Dog {
  constructor(name) { this.name = name; }
  speak() { return `${this.name} barks`; } // trên Dog.prototype
}
const d = new Dog("Rex");
Object.getPrototypeOf(d) === Dog.prototype; // true
```

Vậy nên `d.speak` không được lưu trên `d` — nó được tìm thấy bằng cách đi ngược lên `Dog.prototype`. Đó là lý do mọi con chó chia sẻ một hàm `speak` (tiết kiệm bộ nhớ).

## Tại sao điều này quan trọng

Hiểu prototype chain giải thích: vì sao các instance chia sẻ method, vì sao thay đổi một prototype lại ảnh hưởng đến tất cả object liên kết, cách `instanceof` hoạt động (nó kiểm tra chain), và chi phí của các chuỗi tra cứu dài.

Đó là nền tảng dưới `class`, các built-in (`Array.prototype.map`), và kế thừa.