Skip to main content

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.

A protected setter in TypeScript is a class mutator method defined with the protected access modifier. It restricts the assignment of a class property so that it can only be mutated from within the defining class itself or any of its derived subclasses, strictly preventing modification from external class instances. 
class BaseClass {
    private _internalState: number = 0;

    // The getter must share the exact same access modifier as the setter
    protected get state(): number {
        return this._internalState;
    }

    // The setter accepts a wider type than the getter returns (TypeScript 4.3+)
    protected set state(value: number | string) {
        this._internalState = typeof value === "string" ? parseInt(value, 10) : value;
    }
}

class DerivedClass extends BaseClass {
    public mutateState(newValue: number | string): void {
        // Valid: Subclass has access to the protected setter
        this.state = newValue; 
    }
}

const instance = new DerivedClass();

// Error: Property 'state' is protected and only accessible within class 'BaseClass' and its subclasses.
// instance.state = 42;

​
Technical Mechanics and Rules

1. Symmetric Access Modifiers TypeScript strictly enforces that a get and set accessor for the same property must share the exact same visibility modifier. If a setter is declared as protected, its corresponding getter (if defined) must also be declared as protected. Attempting to mix access modifiers (e.g., a public getter with a protected setter) will result in a compiler error: A 'set' accessor must have the same visibility as the 'get' accessor. 2. Inheritance and Access Scope The protected keyword dictates lexical scoping for the assignment operator (=) when targeting the accessor.
  • Valid: Invoking the setter via this.propertyName = value inside the base class.
  • Valid: Invoking the setter via this.propertyName = value inside a class that extends the base class.
  • Invalid: Invoking the setter via instance.propertyName = value in the global scope or unrelated functions.
3. Signature Constraints and Separate Write Types Regardless of the access modifier, the TypeScript compiler enforces strict signature rules on the setter:
  • It must accept exactly one parameter.
  • It cannot have a return type annotation (not even void).
  • Separate Write Types (TypeScript 4.3+): The setter’s parameter type is permitted to be completely different from the getter’s return type. The compiler only requires that the getter’s return type is assignable to the setter’s parameter type. If no type is explicitly provided to the setter parameter, TypeScript will infer it from the getter’s return type.
Master TypeScript with Deep Grasping Methodology!Learn More