What Is the Prototype Chain?

Every object in JavaScript has an internal link to another object, its prototype. When you read a property that the object does not have itself, the runtime looks at its prototype, and if that object does not have it either, it looks at that object's prototype, and so on until it reaches an object with no prototype at all.

That sequence is the prototype chain, and it is how inheritance works in the language. There is no copying of properties at all. An object that inherits from another does not contain a copy of the parent's properties; it contains a reference to the parent, and lookups walk down it.

const animal = {
  speaks: true,
  describe() { return "I am an animal"; },
};

const dog = Object.create(animal);
dog.name = "Rex";

console.log(dog.name);        // "Rex" - own property
console.log(dog.speaks);      // true - inherited
console.log(Object.getPrototypeOf(dog) === animal);   // true

Two properties of the chain are worth stating. It is a lookup, not a copy, so a change to the parent is visible through every child that inherits from it. And the chain is finite, ending at the object prototype, which itself has no prototype. That last object holds the methods every object has, such as toString and hasOwnProperty.

Because the chain is walked on every miss, an object with many missing properties is slower to read than one where the properties are present directly. That is one of the reasons the engine tracks shapes, so that the common case of many objects with the same layout is fast.

Lookup starts at the object itself and stops at the first match. If the object has an own property with that name, that value is returned and the chain is never walked. If it does not, the runtime moves to the prototype and repeats, until it either finds the property or reaches the end of the chain.

const animal = {
  speaks: true,
  describe() { return "I am an animal"; },
};

const dog = Object.create(animal);
dog.name = "Rex";

// A lookup that walks the chain by hand.
const findOwner = (obj, key) => {
  let current = obj;
  while (current) {
    if (Object.prototype.hasOwnProperty.call(current, key)) return current;
    current = Object.getPrototypeOf(current);
  }
  return null;
};

console.log(findOwner(dog, "name") === dog);      // true
console.log(findOwner(dog, "speaks") === animal);  // true
console.log(findOwner(dog, "missing"));           // null

The lookup is a search for an own property at each level. The hasOwnProperty check is what distinguishes an own property from an inherited one at each step, and calling it through the object prototype rather than as a method on the object is the safe habit, because a user object could have a property of that name that shadows it.

Two things that surprise people. A property set to the empty value on the object still shadows the inherited one, because shadowing depends on the key existing, not on the value being meaningful. And assigning to a property that only exists on the prototype creates an own property on the object rather than changing the prototype, so the inherited value stays where it was.

For the interview, the key distinction to draw is between the in operator and the hasOwnProperty check. The in operator finds inherited properties as well, so it answers whether the property is reachable, while hasOwnProperty answers whether it belongs to the object itself.

There are two ways to build the link. The class syntax creates the link for you, and the create method sets it explicitly, which is the raw form underneath.

class Animal {
  constructor(name) { this.name = name; }
  speak() { return `${this.name} makes a sound`; }
}

class Dog extends Animal {
  speak() { return `${this.name} barks`; }
}

const rex = new Dog("Rex");
console.log(rex.name);                // "Rex"
console.log(rex.speak());             // "Rex barks"
console.log(rex instanceof Animal);   // true
console.log(rex instanceof Dog);      // true

// The raw form of the same idea.
const proto = { speak() { return `${this.name} makes a sound`; } };
const dog = Object.create(proto);
dog.name = "Bit";

console.log(dog.speak());             // "Bit makes a sound"
console.log(Object.getPrototypeOf(dog) === proto);   // true

The instance check works by walking the prototype chain, which is why a Dog instance is both a Dog and an Animal. The instanceof operator asks whether the constructor's prototype appears anywhere in the object's chain.

One important detail about the class version. The constructor of a derived class implicitly calls the parent constructor with the given arguments before its own body runs, so the parent initialisation happens first. That matters when a parent constructor does validation or sets defaults that the child then relies on.

The raw version is worth being able to write because it shows what the class syntax compiles down to, and because it is still the quickest way to build a lightweight object with shared behaviour. The class version adds the extra machinery of constructors, private fields and static members on top of the same prototype link.