JavaScript Classes

Advanced

JavaScript classes provide class syntax without replacing JavaScript’s object and prototype model. This lesson owns the class-specific language: declarations and expressions, constructors, class elements, public and private fields, methods and accessors, static members, inheritance, super, private brand checks, and static initialization. Prototype lookup itself belongs to the Objects and Prototypes lesson; function-call this rules belong to Function Objects and this; error construction belongs to Errors and Defensive Control Flow.

How to use this lesson

Run each example before reading the explanation. The goal is to observe where class-created behavior lives and when initialization happens, then connect that behavior to the ECMAScript model. The examples deliberately avoid re-teaching general prototype lookup, descriptors, or function-call semantics already owned by other lessons.

A class declaration produces a class value

?

A class expression is itself an expression

?

Constructor calls initialize instances

?

Instance methods are prototype-backed

?

Class bodies are strict mode code

?

Public instance fields are per-instance

?

Field initializers can observe earlier instance fields

?

Static members belong to the class value

?

extends establishes class inheritance

?

Derived constructors use super before this

?

super method calls preserve the current receiver

?

Private fields are not ordinary properties

?

Private methods and accessors are class-private elements

?

Private presence can be tested with #name in object

?

Static initialization blocks run during class evaluation

?

Static private elements belong to the class

?

Class initialization order matters

A class body is evaluated as a sequence of class elements. Static fields and static initialization blocks run during class definition in source order. Instance fields and instance private elements are initialized as part of construction, also according to the class’s defined initialization order. Derived construction adds the superclass step before derived instance initialization can proceed. These ordering rules are often more important than memorizing syntax.

Authoring rules

• Use a class when a coherent instance protocol, construction model, or inheritance relationship makes the class syntax clearer than unrelated functions and objects.

• Remember that ordinary instance methods are prototype-backed; do not assume each instance owns a fresh method function.

• Use instance fields for per-instance state and static fields for state associated with the class value.

• Use private elements when the invariant requires language-enforced private names; #name is not a string property key.

• In derived constructors, call super() before reading or writing this.

• Treat static initialization blocks as class-evaluation work, and keep side effects there deliberate because they run when the class is evaluated.

• Do not use inheritance merely to share a small helper. Composition, functions, or plain objects can express a simpler relationship.

Practice

Build a small Shape → Rectangle hierarchy. Give Rectangle one public instance field and one private field, add a shared instance method, add a static factory, and include a static initialization block. Then inspect which values are on the instance, which are on the prototype, and which belong to the class value. Keep the inspection focused on class-specific behavior rather than repeating the prototype lesson.

Specification references

Normative authority: ECMA-262, current living specification. The central language area is the Functions and Classes chapter, especially Class Definitions and its evaluation semantics. Related semantics include private elements, private environments, ordinary object/prototype behavior, and execution contexts.