Explain the prototype chain. What happens on property lookup? How does `class` relate to it?
Whether you know `class` is syntactic sugar over prototypes, not a new model.
Every object has an internal [[Prototype]] link (read via Object.getPrototypeOf). On property lookup, the engine checks the object, then its prototype, then that prototype's prototype, up the chain until it finds the key or hits null. Methods live on the prototype so all instances share one copy. `class` is sugar: methods go on the prototype, `extends` wires the chain, `super` walks up it. Key distinctions interviewers probe: an instance's [[Prototype]] points to its constructor's .prototype object (not to the constructor itself) — new Dog() links to Dog.prototype, whose [[Prototype]] links to Animal.prototype. Property WRITES don't walk the chain: assigning obj.x creates an own property on obj (shadowing), it never mutates the prototype — which is why shared state on a prototype is a footgun. hasOwnProperty distinguishes own from inherited keys, and for...in walks inherited enumerables while Object.keys returns only own ones. Prefer class/Object.create over the legacy Constructor.prototype = new Parent() pattern.
Understanding instanceof, why adding to Array.prototype affects all arrays, and the memory efficiency of shared methods.