Static Private Setter

A static private setter in JavaScript is a class-level mutator method, prefixed with a hash identifier (#), that intercepts assignments to a specific property name. It is bound to the class constructor rather than prototype instances, and its invocation is strictly confined to the lexical scope of the class body.

Syntax

A static private setter is defined using the static and set keywords, followed by the # prefix and the identifier name. It must accept exactly one parameter.

class ClassName {
  static set #identifier(value) {
    // Mutation logic
  }
}

Mechanics and Invocation

Unlike standard methods, setters are not invoked with parentheses. They are invoked implicitly via the assignment operator (=). Because the setter is both static and private, it can only be triggered from within other static methods, static initialization blocks, or instance methods belonging to the same class.

class Engine {
  static #temperature = 0;

  // Definition of the static private setter
  static set #coreTemp(value) {
    if (typeof value !== 'number') {
      throw new TypeError("Temperature must be a number");
    }
    Engine.#temperature = value;
  }

  static calibrate(newTemp) {
    // Invocation via assignment within the class lexical scope
    Engine.#coreTemp = newTemp; 
    
    // 'this.#coreTemp = newTemp' is also valid here, 
    // as 'this' refers to the Engine class in a static context.
  }
}

Engine.calibrate(90); // Executes successfully

// External access attempts result in a SyntaxError
// Engine.#coreTemp = 100; 

Technical Characteristics

• Arity Restriction: The ECMAScript specification mandates that a setter must have exactly one parameter. Defining a static private setter with zero or multiple parameters throws a SyntaxError.
• Execution Context (this): When the setter is invoked, the this binding inside the setter body evaluates to the class constructor itself, not an instance of the class.
• Identifier Conflicts: A static private setter can share the same identifier as a static private getter (e.g., static get #prop()). However, it cannot share an identifier with a static private data field (e.g., static #prop = 10;); doing so results in a SyntaxError for redeclaration.
• Inheritance and Subclassing: Private static members are not inherited. If a subclass attempts to invoke a parent class’s static private setter via this.#setter (where this evaluates to the subclass), JavaScript will throw a TypeError indicating an illegal invocation, as the private identifier is not branded onto the subclass. Invocation must explicitly target the defining class (e.g., ParentClass.#setter = value).

Master JavaScript with Deep Grasping Methodology!

Learn More