What is the prototype chain in JavaScript?

Question

Accepted Answer

The prototype chain is how JavaScript implements inheritance. Every object has an internal link ( [[Prototype]] ) to another object called its prototype . When you access a property, the engine walks up this chain until it finds a match or reaches null . Setting up the chain An object's prototype is set at creation time. Object.create(proto) sets it directly; constructor functions do so via their prototype property; class extends pipes through the same machinery. const animal = { eats: true }; const dog = Object.create(animal); dog.barks = true; dog.eats; // true (inherited from animal) dog.barks; // true (own property) How lookups walk the chain When you read obj.prop , the engine checks obj 's own properties first. Missing it, it moves to Object.getPrototypeOf(obj) , and so on, until it hits null . Writing a property always creates or overwrites it on the object itself, never on a prototype. Constructor functions and prototype Every function has a prototype property. When called with new , the created instance's [[Prototype]] is set to Constructor.prototype . That is how methods defined on Constructor.prototype become available on every instance. function Animal(name) { this.name = name; } Animal.prototype.speak = function () { return this.name + " makes a sound"; }; const a = new Animal("Rex"); a.speak(); // "Rex makes a sound" Object.getPrototypeOf(a) === Animal.prototype; // true Classes are syntactic sugar A class declaration still builds a prototype chain under the hood. extends wires the child class's prototype to the parent's, enabling method lookup up the chain. The default chain for a plain object {} — your object Object.prototype — home of hasOwnProperty , toString , etc. null — end of the chain Inspecting and changing prototypes Object.getPrototypeOf(obj) — read the prototype. Object.setPrototypeOf(obj, proto) — change it (slow; avoid in hot paths). obj.hasOwnProperty(key) — check for own (non-inherited) properties. obj instanceof Constructor — walks the chain looking for Constructor.prototype . Draw the chain: instance → Constructor.prototype → Object.prototype → null. Know hasOwnProperty (own only) vs in (includes prototype). Object.create is the cleanest prototype setup. The lookup algorithm (own first, then chain) is the core concept.