Explain prototypal inheritance.

Q: Explain prototypal inheritance.

**Target Audience:** Engineers preparing for JavaScript object-model and inheritance interview questions. **Difficulty:** Medium > **How to read this doc:** Concepts are explained in plain language first, then tagged with 📌 Interview term: . Every result below was actually run on Node.js v24.19.0 — the printed output is real, captured output, not illustrative sample text. This doc covers the MECHANISM (how prototypal inheritance actually works); for how it conceptually differs from classical, class-based inheritance, see Explain how prototypal inheritance differs from classical inheritance. , and for a focused, definitional look at the lookup mechanism alone, see What is the prototype chain? ## 1. Why This Even Matters — A Story First Picture a small company where nobody has their own copy of

The problem

Question presented to candidate: "Explain what prototypal inheritance actually is in JavaScript, and how the mechanism works under the hood."

What a strong answer should cover:

Every JavaScript object has a hidden internal link, the [[Prototype]] slot, pointing to another object (or to null).
Property lookup walks this link: if a property is not found directly on an object, the engine automatically checks the object's prototype, then that prototype's own prototype, and so on, until it finds the property or reaches null.
Object.create(proto) is the most direct way to create an object with a chosen prototype, with no constructor function involved at all.
Ctor.prototype (a plain object property that lives on a function) and instance.proto (the actual internal link on an instance) are two distinct but related things, and mixing them up is a very common source of confusion.
Because lookup happens live at call time rather than by copying, patching a shared prototype after instances already exist changes the behavior of every existing instance -- inheritance is genuinely dynamic, not a one-time copy.

Clarifying questions expected:

"Should I also contrast this with classical, class-based inheritance, or focus purely on how the JavaScript mechanism itself works?" (the comparison has its own dedicated question)

Code / implementation expected: Yes -- a runnable snippet showing Object.create-based delegation and a live patch to a shared prototype changing an existing instance's behavior.

prototypes
inheritance
objects
oop

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for JavaScript object-model and inheritance interview questions. Difficulty: Medium

How to read this doc: Concepts are explained in plain language first, then tagged with 📌 Interview term:. Every result below was actually run on Node.js v24.19.0 — the printed output is real, captured output, not illustrative sample text. This doc covers the MECHANISM (how prototypal inheritance actually works); for how it conceptually differs from classical, class-based inheritance, see Explain how prototypal inheritance differs from classical inheritance., and for a focused, definitional look at the lookup mechanism alone, see What is the prototype chain?

1. Why This Even Matters — A Story First

Picture a small company where nobody has their own copy of the employee handbook. A new hire does not get handed a personal, duplicated rulebook -- they

The solution is hidden so you can try first

8 min read · 9 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptObject.create delegation, prototype vs __proto__, and live (non-copied) inheritance (run directly)