Static Setter

A static setter in TypeScript is a method prefixed with the static and set keywords that intercepts assignment operations to a property on the class constructor itself, rather than on instances of the class. It allows you to execute custom logic, such as validation or data transformation, whenever a specific static property is mutated.

Because static members belong to the class object rather than the prototype chain, a static setter is invoked directly on the class identifier.

Syntax

class ClassName {
    private static _backingField: Type;

    static set propertyName(value: Type) {
        ClassName._backingField = value;
    }
}

Technical Constraints and Behavior

• Single Parameter: A static setter must accept exactly one required parameter. It cannot accept zero parameters, nor can it accept multiple parameters or optional parameters.
• No Return Type: TypeScript strictly forbids defining a return type annotation on a setter (static or instance). The setter implicitly evaluates to the assigned value, but you cannot explicitly type it as void or any other type.
• Execution Context: Inside a static setter, the this keyword refers to the class constructor function itself, not an instance of the class. However, it is a common convention to reference the class name directly (e.g., ClassName.property) to avoid context-binding issues.
• Access Modifiers: Static setters can be scoped using public, protected, or private access modifiers. If omitted, the default is public.
• Type Relationship (TS 4.3+): If a static setter is paired with a static getter of the same name, TypeScript 4.3 and later allows the setter’s parameter type to be wider (more permissive) than the getter’s return type. If no type is provided for the setter parameter, it is inferred from the getter’s return type.

Mechanics Example

The following example demonstrates the structural relationship between a static setter, a private static backing field, and the assignment operation that triggers the setter.

class ServerConfig {
    // Private static backing field
    private static _timeout: number = 5000;

    // Static setter
    public static set timeout(value: number | string) {
        // Type narrowing and transformation logic
        const parsedValue = typeof value === "string" ? parseInt(value, 10) : value;
        
        if (isNaN(parsedValue)) {
            throw new TypeError("Invalid timeout value");
        }

        // State mutation on the class constructor
        ServerConfig._timeout = parsedValue;
    }

    // Static getter (narrower return type than setter parameter)
    public static get timeout(): number {
        return ServerConfig._timeout;
    }
}

// Triggers the static setter, passing a number
ServerConfig.timeout = 10000;

// Triggers the static setter, passing a string
ServerConfig.timeout = "8000"; 

Master TypeScript with Deep Grasping Methodology!

Learn More