1
Classical inheritance is based on a strict class hierarchy with clear parent-child relationships. Prototypal inheritance is more flexible and allows for more dynamic and ad-hoc object relationships.
2
Classical inheritance involves creating instances of predefined classes. Prototypal inheritance involves cloning or extending existing objects to create new objects.
3
Classical inheritance can be less flexible due to the rigid class hierarchy and compilation-time definitions. Prototypal inheritance offers greater flexibility and adaptability, allowing objects to be easily modified and extended at runtime.
4
In conventional inheritance, changing a base class can break an entire hierarchy because the structure is so rigid. In JavaScript, because it is Delegation-based, you can swap prototypes or augment them dynamically, making the code more 'composed' and flexible.

Difficulty: 5/10

Topics: prototype chain, ES6 class syntax, inheritance patterns

0-2 years experience

1
If you need to create a simple 'Car' object that shares a 'drive' method with all instances, would you use a constructor function with prototype or an ES6 class? Walk me through the steps.
2
What happens when you assign a property directly on an object versus on its prototype? How does that affect instances created later?

2-5 years experience

1
We have a codebase that mixes prototype inheritance and ES6 class syntax, and a bug appears where a subclass method doesn't override the parent. How would you debug it and what inheritance differences might be causing the issue?
2
When adding a new feature, you need to extend a third‑party library that provides a prototype‑based API, but your team prefers class syntax. What trade‑offs would you consider and how would you implement the extension?

5-8 years experience

1
Our front‑end framework creates thousands of component instances per page. Discuss the performance implications of using prototype‑based inheritance versus class‑based inheritance for these components.
2
Design a module that abstracts over both prototype and class inheritance so that other teams can use whichever style they prefer without breaking. What edge cases would you handle?

8+ years experience

1
We are planning a migration of a large legacy codebase that heavily uses prototype inheritance to modern ES6 class syntax. How would you approach the migration to minimize risk and ensure cross‑team consistency?
2
From an architectural standpoint, what are the long‑term maintenance considerations when choosing prototype‑based inheritance over class‑based inheritance in a shared library used across multiple products?

❓Can you give an example where prototype inheritance offers an advantage over class syntax?
❓How does the 'super' keyword work under the hood in ES6 classes?
❓What impact does this have on tooling like linters or type systems?