Modern ES6+ Classes: Constructors, #private Fields & Subclassing

01Classes: Declarative Prototype Sugar

Introduced in ES2015, the class syntax provides a clean, declarative syntax for creating objects and managing inheritance. However, it is vital to understand that JavaScript did not introduce a new object-oriented inheritance model: under the hood, classes still compile directly to constructor functions and prototype delegation.

A class definition encapsulates the constructor, prototype methods, static methods, and instance fields into a single unified construct. Classes execute strictly in strict mode by default and cannot be called without the new keyword (attempting ClassName() without new throws a TypeError).

Before ECMAScript 2015, achieving true data privacy in JavaScript was only possible using closures inside constructor functions. This had a significant downside: every object instance duplicated method closures in heap memory, preventing memory sharing via the prototype chain.

The introduction of private instance fields with the hash prefix (#field) in modern ECMAScript solved this permanently. Private fields are stored in a dedicated internal slot on the instance, managed directly by the V8 engine. They are syntactically and reflectively invisible from outside the class body—not even Object.getOwnPropertyNames() or Proxy traps can read them.

02True Private Fields with Hash (#)

For decades, JavaScript developers relied on convention (such as prefixing property names with an underscore _privateKey) or closures to simulate private variables. In modern ECMAScript, true encapsulation arrived with Private Class Fields, declared with a leading hash (#) symbol.

Private fields cannot be accessed, read, or modified from outside the class body. They are not accessible via Object.keys(), Object.getOwnPropertyNames(), or even reflective proxies. Attempting to access an unexposed private field from outside throws a hard syntax error or TypeError at runtime.

Under the hood, class inheritance via 'extends' wires up two distinct prototype chains simultaneously: instance inheritance and static inheritance.

SubClass.prototype delegates to SuperClass.prototype (so child instances inherit parent methods), and SubClass constructor function delegates directly to SuperClass constructor function (so static utility methods like User.findById are inherited by Admin.findById automatically). This dual delegation is a hallmark of clean object-oriented architecture.

03Subclassing and the Super Keyword

The extends keyword sets up prototype delegation between both the constructor functions (for static methods) and their prototypes (for instance methods). When a derived child class defines a constructor, it must call super() before accessing this.

super() invokes the parent class constructor and initializes the this binding. Inside overridden methods, super.methodName() allows invoking the parent's original implementation, enabling clean polymorphic extensions.

04Why This Matters in Production

Modern frameworks and enterprise libraries structure complex subsystems (ORM models, HTTP clients, UI components) using modern class hierarchies. Utilizing private fields (#) ensures that internal implementation details remain un-leaked, preventing downstream consumers from coupling directly to internal variables.

Keep class inheritance shallow: deep inheritance hierarchies create tight coupling and fragile base-class problems. Favor composition and behavior delegation over 5-level-deep class hierarchies.