Static Setter

A static setter is a method defined on a class constructor that intercepts property assignment operations for the class itself, rather than for instances of the class. By combining the static and set keywords, it binds a class-level property to a function that executes automatically whenever that specific property is assigned a value.

Syntax

class ClassName {
  static set propertyName(value) {
    // Assignment logic
  }
}

Technical Mechanics

• Execution Context: Inside a static setter, the this keyword refers to the class constructor object itself, not an instance of the class.
• Parameter Constraints: A static setter must accept exactly one parameter, which represents the value being assigned. Attempting to define a setter with zero or multiple parameters will throw a SyntaxError.
• Prototype Placement: Unlike instance setters (which are defined on ClassName.prototype), static setters are defined directly on the class object.
• Property Descriptors & Overwriting: A static setter can share its identifier with a static getter to form a complete accessor property. If a static setter shares an identifier with a standard static method, lexical order determines the outcome: the last declared item in the class body overwrites the previous one. However, if a static setter shares an identifier with a static data property (class field), the static field will always overwrite the static setter, regardless of lexical order. This occurs because the ECMAScript specification dictates that static fields are initialized only after all methods and accessors have been installed on the class object.
• Inheritance: Static setters are inherited by subclasses via the prototype chain of the class constructors. When a subclass triggers the inherited setter, the this binding inside the setter evaluates to the subclass, not the parent class.

Behavior Visualization

class BaseEntity {
  static _registryCount = 0;

  // Defines the static setter
  static set count(value) {
    if (!Number.isInteger(value)) {
      throw new TypeError("Count must be an integer.");
    }
    // 'this' refers to the class invoking the setter
    this._registryCount = value;
  }

  static get count() {
    return this._registryCount;
  }
}

class SubEntity extends BaseEntity {}

// 1. Invoked directly on the class
BaseEntity.count = 5; 
console.log(BaseEntity.count); // 5

// 2. Inherited and invoked on a subclass
// 'this' evaluates to SubEntity, creating SubEntity._registryCount
SubEntity.count = 10; 
console.log(SubEntity.count); // 10
console.log(BaseEntity.count); // 5 (Parent class state remains untouched)

// 3. Bypassed by instances
const instance = new BaseEntity();
instance.count = 20; // Creates a standard data property on the instance
console.log(instance.count); // 20
console.log(BaseEntity.count); // 5 (Class static property is unaffected)

Deletion and Reconfiguration

Because static setters are properties of the class object, they are configurable by default. You can remove a static setter at runtime using the delete operator on the class constructor:

delete BaseEntity.count;

Alternatively, its descriptor can be modified using Object.defineProperty() directly on the class object.

Master JavaScript with Deep Grasping Methodology!

Learn More