How does prototypal inheritance work?

Question

Accepted Answer

Every JavaScript object has a hidden link to another object called its **prototype**. When you access a property, JS looks on the object itself, then walks up this **prototype chain** until it finds the property or reaches `null`. This is *delegation*, not copying.

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

## How classes use it

`class` is syntax sugar over prototypes. Methods live **once** on the prototype, shared by all instances (not copied per object):

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

So `d.speak` isn't stored on `d` — it's found by walking up to `Dog.prototype`. That's why all dogs share one `speak` function (memory-efficient).

## Why it matters

Understanding the chain explains: why instances share methods, why changing a prototype affects all linked objects, how `instanceof` works (it checks the chain), and the cost of long lookup chains.

It's the foundation under `class`, built-ins (`Array.prototype.map`), and inheritance.