Lesson 6 of 80

Prototypes & the prototype chain

Q: How does inheritance work in JavaScript?

A strong answer covers: Objects have a prototype link; lookups walk up the prototype chain; It's delegation, not copying; class is syntactic sugar over the prototype mechanism.

How objects inherit in JavaScript — a chain of delegation that class quietly sits on top of.

16 min read

Check your understanding

Every option explains itself — why the right one is right, and why each wrong one is wrong. Miss one and it comes back later on a spaced-repetition schedule.

Question 1 of 2

When you call `[1,2,3].map(...)`, where does the `map` method actually live?

On Array.prototype, found by walking the prototype chainDirectly on the array instance you createdIt's a global function that arrays can call

Stuck? Ask the AI tutor

Hints without spoilers, and a plain explanation of why a wrong answer was wrong — answered only from this lesson. Free account, no card.

Interview questions on Prototypes & the prototype chain

What interviewers actually ask about this, and what a strong answer has to cover.

How does inheritance work in JavaScript?

A strong answer covers

Objects have a prototype link; lookups walk up the prototype chain
It's delegation, not copying
class is syntactic sugar over the prototype mechanism

Likely follow-ups

You used the word inheritance — is JavaScript actually copying anything, or is something else going on?
Where does the chain end, and what does that have to do with getting `undefined` for a missing property?
If class is 'just sugar', what exactly is it sugaring — what would the prototype version look like?

Practice these with the AI interviewer →

The plain-language idea

Every JavaScript object has a hidden link to another object called its prototype. When you ask for a property the object doesn't have, JavaScript follows that link and checks the prototype — and its prototype — until it finds the property or hits the end.

That walk is the prototype chain. It isn't copying; it's delegation — "I don't have it, ask the next one up."

See it in a real thing

Array methods aren't on your array — they live one link up:

const list = [1, 2, 3];
list.map;                 // found on Array.prototype, not on `list` itself
list.hasOwnProperty("0"); // found further up, on Object.prototype

And class is sugar over exactly this:

class Animal { speak() { return "..."; } }
class Dog extends Animal { speak() { return "woof"; } }
// Dog.prototype's link points to Animal.prototype — that link is the chain.

The prototype chain: where map actually livesStep 1 of 5

You call [1,2,3].map(...). JavaScript looks on the array itself first.

What people usually miss

Watch out

The chain ends at null. Object.prototype's prototype is null — which is why unknown lookups eventually return undefined.
Shadowing. A property on the object itself hides one with the same name further up the chain.
class didn't replace prototypes — it's a cleaner way to write them. Understand one and you understand the other.

Why this matters in interviews

"How does inheritance work in JavaScript?" wants the word prototype, not class. If you can say objects delegate up a chain and class is sugar over it, you've answered the real question.