Question 1

How does object-oriented programming work in JavaScript compared to classical OOP languages?

Accepted Answer

JS is prototype-based; ES6 classes are syntactic sugar over constructor functions and prototypes, with some semantic differences (e.g. non-callable without new). Instead of class-copy inheritance (classical), JS links objects via prototypes. You can still model encapsulation, inheritance, and polymorphism. class syntax provides constructors, extends, super, static members, and private fields (#), but underneath instances still delegate to prototypes. Objects are dynamic: properties can be added at runtime. Mixins and composition are idiomatic alternatives to deep hierarchies. Interviewers often want you to acknowledge both the prototype model and modern class ergonomics.

Question 2

Explain extends and super in JavaScript classes. What must a derived constructor do before using this?

Accepted Answer

extends sets up prototype linkage; derived constructors must call super() before accessing this so the parent can initialize the instance. class Child extends Parent makes Child.prototype delegate to Parent.prototype and sets Child.[[Prototype]] to Parent for static inheritance. In the child constructor, super(args) invokes the parent constructor with the current new.target. Until super returns, this is uninitialized in the derived constructor — accessing it throws. super.method() in a method calls the parent prototype's method with the same this. Arrow fields are not on the prototype, so super patterns differ. Returning an object from a constructor still overrides the instance.

Question 3

When would you choose composition over inheritance in a JavaScript codebase?

Accepted Answer

Prefer composition when behavior is reusable across unrelated types or hierarchies would be deep/fragile; use inheritance for true 'is-a' with shared identity. Inheritance couples types: changes in a base class ripple downward (fragile base class). Composition (has-a) plugs small collaborators into a host object/function, easing testing and reuse. In JS, composition is natural via closures, dependency injection, and mixins — but mixins can conflict. Use inheritance for framework extension points (extends Component) or clear taxonomic relationships. A practical heuristic: if you only need a few methods, wrap or delegate; if you need polymorphism with shared interface and lifecycle, inheritance or explicit interfaces (TypeScript) may fit.

Question 4

Compare ES private class fields (#) with WeakMap-based privacy patterns.

Accepted Answer

#fields are language-enforced per-class privacy; WeakMaps associate hidden data with objects without exposing properties — useful for wrapping external objects. Private fields are only accessible inside the class body (including its methods); access from outside throws. They are not inherited as accessible names in subclasses (subclasses declare their own #). WeakMap privacy stores values keyed by the instance; if you don't export the map, data is effectively private and entries don't prevent GC. WeakMaps can decorate objects you don't control (e.g. DOM nodes). Trade-offs: # is clearer and faster in engines for typical class design; WeakMap is more flexible for libraries that attach metadata. Neither is a security boundary across realms.

Question 5

You are leading a redesign of a large JS domain layer that mixed anemic data objects with scattered business rules. How would you structure OOP (or FP) boundaries?

Accepted Answer

Define clear domain entities/services with invariants in one place; keep infrastructure (HTTP/DB/UI) outside; prefer small composable types over deep class trees. Start by identifying bounded contexts and ubiquitous language. Model invariants on entities/value objects (classes or factories that validate on construction). Put use-cases in application services that orchestrate domain objects — avoid UI components owning rules. Prefer composition of policies/strategies over a mega-base Entity. Decide immutability defaults for value objects. For JS/TS, TypeScript interfaces + modules often beat deep inheritance. Establish testing strategy: pure domain unit tests without DOM/network. Migration: strangler-fig new modules beside legacy anemic models; forbid new business logic in controllers. Measure success by reduced duplication and fewer cross-layer leaks.

OOP JavaScript Interview Questions

Other JavaScript interview topics