Classes are in fact "specialfunctions", and just as you can definefunction expressions andfunction declarations, a class can be defined in two ways: aclass expression or aclass declaration.

// Declarationclass Rectangle {  constructor(height, width) {    this.height = height;    this.width = width;  }}// Expression; the class is anonymous but assigned to a variableconst Rectangle = class {  constructor(height, width) {    this.height = height;    this.width = width;  }};// Expression; the class has its own nameconst Rectangle = class Rectangle2 {  constructor(height, width) {    this.height = height;    this.width = width;  }};

Like function expressions, class expressions may be anonymous, or have a name that's different from the variable that it's assigned to. However, unlike function declarations, class declarations have the sametemporal dead zone restrictions aslet orconst and behave as if they arenot hoisted.

The body of a class is the part that is in curly braces{}. This is where you define class members, such as methods or constructor.

The body of a class is executed instrict mode even without the"use strict" directive.

A class element can be characterized by three aspects:

• Kind: Getter, setter, method, or field
• Location: Static or instance
• Visibility: Public or private

Together, they add up to 16 possible combinations. To divide the reference more logically and avoid overlapping content, the different elements are introduced in detail in different pages:

Method definitions

Public instance method

getter

Public instance getter

setter

Public instance setter

Public class fields

Public instance field

static

Public static method, getter, setter, and field

Private properties

Everything that's private

In addition, there are two special class element syntaxes:constructor andstatic initialization blocks, with their own references.

Constructor

Theconstructor method is a special method for creating and initializing an object created with a class. There can only be one special method with the name "constructor" in a class — aSyntaxError is thrown if the class contains more than one occurrence of aconstructor method.

A constructor can use thesuper keyword to call the constructor of the super class.

You can create instance properties inside the constructor:

class Rectangle {  constructor(height, width) {    this.height = height;    this.width = width;  }}

Alternatively, if your instance properties' values do not depend on the constructor's arguments, you can define them asclass fields.

Static initialization blocks

Static initialization blocks allow flexible initialization ofstatic properties, including the evaluation of statements during initialization, while granting access to the private scope.

Multiple static blocks can be declared, and these can be interleaved with the declaration of static fields and methods (all static items are evaluated in declaration order).

Methods

Methods are defined on the prototype of each class instance and are shared by all instances. Methods can be plain functions, async functions, generator functions, or async generator functions. For more information, seemethod definitions.

class Rectangle {  constructor(height, width) {    this.height = height;    this.width = width;  }  // Getter  get area() {    return this.calcArea();  }  // Method  calcArea() {    return this.height * this.width;  }  *getSides() {    yield this.height;    yield this.width;    yield this.height;    yield this.width;  }}const square = new Rectangle(10, 10);console.log(square.area); // 100console.log([...square.getSides()]); // [10, 10, 10, 10]

Static methods and fields

Thestatic keyword defines a static method or field for a class. Static properties (fields and methods) are defined on the class itself instead of each instance. Static methods are often used to create utility functions for an application, whereas static fields are useful for caches, fixed-configuration, or any other data that doesn't need to be replicated across instances.

class Point {  constructor(x, y) {    this.x = x;    this.y = y;  }  static displayName = "Point";  static distance(a, b) {    const dx = a.x - b.x;    const dy = a.y - b.y;    return Math.hypot(dx, dy);  }}const p1 = new Point(5, 5);const p2 = new Point(10, 10);p1.displayName; // undefinedp1.distance; // undefinedp2.displayName; // undefinedp2.distance; // undefinedconsole.log(Point.displayName); // "Point"console.log(Point.distance(p1, p2)); // 7.0710678118654755

Field declarations

With the class field declaration syntax, theconstructor example can be written as:

class Rectangle {  height = 0;  width;  constructor(height, width) {    this.height = height;    this.width = width;  }}

Class fields are similar to object properties, not variables, so we don't use keywords such asconst to declare them. In JavaScript,private properties use a special identifier syntax, so modifier keywords likepublic andprivate should not be used either.

As seen above, the fields can be declared with or without a default value. Fields without default values default toundefined. By declaring fields up-front, class definitions become more self-documenting, and the fields are always present, which help with optimizations.

Seepublic class fields for more information.

Private properties

Using private fields, the definition can be refined as below.

class Rectangle {  #height = 0;  #width;  constructor(height, width) {    this.#height = height;    this.#width = width;  }}

It's an error to reference private fields from outside of the class; they can only be read or written within the class body.By defining things that are not visible outside of the class, you ensure that your classes' users can't depend on internals, which may change from version to version.

Private fields can only be declared up-front in a field declaration. They cannot be created later through assigning to them, the way that normal properties can.

For more information, seeprivate properties.

Theextends keyword is used inclass declarations orclass expressions to create a class as a child of another constructor (either a class or a function).

class Animal {  constructor(name) {    this.name = name;  }  speak() {    console.log(`${this.name} makes a noise.`);  }}class Dog extends Animal {  constructor(name) {    super(name); // call the super class constructor and pass in the name parameter  }  speak() {    console.log(`${this.name} barks.`);  }}const d = new Dog("Mitzie");d.speak(); // Mitzie barks.

If there is a constructor present in the subclass, it needs to first callsuper() before usingthis. Thesuper keyword can also be used to call corresponding methods of super class.

class Cat {  constructor(name) {    this.name = name;  }  speak() {    console.log(`${this.name} makes a noise.`);  }}class Lion extends Cat {  speak() {    super.speak();    console.log(`${this.name} roars.`);  }}const l = new Lion("Fuzzy");l.speak();// Fuzzy makes a noise.// Fuzzy roars.

When aclass declaration orclass expression is evaluated, its various components are evaluated in the following order:

1. Theextends clause, if present, is first evaluated. It must evaluate to a valid constructor function ornull, or aTypeError is thrown.
2. Theconstructor method is extracted, substituted with a default implementation ifconstructor is not present. However, because theconstructor definition is only a method definition, this step is not observable.
3. The class elements' property keys are evaluated in the order of declaration. If the property key is computed, the computed expression is evaluated, with thethis value set to thethis value surrounding the class (not the class itself). None of the property values are evaluated yet.
4. Methods and accessors are installed in the order of declaration. Instance methods and accessors are installed on theprototype property of the current class, and static methods and accessors are installed on the class itself. Private instance methods and accessors are saved to be installed on the instance directly later. This step is not observable.
5. The class is now initialized with the prototype specified byextends and implementation specified byconstructor. For all steps above, if an evaluated expression tries to access the name of the class, aReferenceError is thrown because the class is not initialized yet.
6. The class elements' values are evaluated in the order of declaration:
   • For eachinstance field (public or private), its initializer expression is saved. The initializer is evaluated during instance creation, at the start of the constructor (for base classes) or immediately before thesuper() call returns (for derived classes).
   • For eachstatic field (public or private), its initializer is evaluated withthis set to the class itself, and the property is created on the class.
   • Static initialization blocks are evaluated withthis set to the class itself.
7. The class is now fully initialized and can be used as a constructor function.

For how instances are created, see theconstructor reference.

When a static or instance method is called without a value forthis, such as by assigning the method to a variable and then calling it, thethis value will beundefined inside the method. This behavior is the same even if the"use strict" directive isn't present, because code within theclass body is always executed in strict mode.

class Animal {  speak() {    return this;  }  static eat() {    return this;  }}const obj = new Animal();obj.speak(); // the Animal objectconst speak = obj.speak;speak(); // undefinedAnimal.eat(); // class Animalconst eat = Animal.eat;eat(); // undefined

If we rewrite the above using traditional function-based syntax in non–strict mode, thenthis method calls are automatically bound toglobalThis. In strict mode, the value ofthis remains asundefined.

function Animal() {}Animal.prototype.speak = function () {  return this;};Animal.eat = function () {  return this;};const obj = new Animal();const speak = obj.speak;speak(); // global object (in non–strict mode)const eat = Animal.eat;eat(); // global object (in non-strict mode)

• Using classes guide
• class
• class expression
• Functions
• ES6 In Depth: Classes on hacks.mozilla.org (2015)