> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# TypeScript 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
```typescript theme={"dark"}
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.
```typescript theme={"dark"}
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";
```
Tired of Poor TypeScript Skills? Fix That With Deep Grasping!
Learn More
