Модификаторы доступа TypeScript: public, private, protected

В TypeScript три модификатора доступа для членов класса: public (по умолчанию), protected и private. Они определяют, где можно использовать член, и компилятор сообщает о любом обращении не из того места.

class Employee {
    public name: string;          // anywhere (public is the default)
    protected salary: number;     // this class and subclasses
    private ssn: string;          // this class only

    constructor(name: string, salary: number, ssn: string) {
        this.name = name;
        this.salary = salary;
        this.ssn = ssn;
    }

    maskedSsn(): string {
        return "***-**-" + this.ssn.slice(-4); // fine: inside the class
    }
}

const e = new Employee("Ada", 5000, "123-45-6789");
console.log(e.name, e.maskedSsn()); // Ada ***-**-6789

// @ts-expect-error: Property 'ssn' is private and only accessible within class 'Employee'.
console.log(e.ssn);

Последняя строка это ошибка компиляции, но посмотрите, что она напечатала, когда её всё-таки запустили: 123-45-6789. Это самый важный факт на этой странице, и раздел о private его объясняет.

Что разрешает каждый модификатор

Модификаторы работают для полей, методов, геттеров и сеттеров, конструкторов и свойств-параметров (constructor(private id: string)). Писать public необязательно, и многие кодовые базы его опускают.

private это проверка времени компиляции

TypeScript стирает private вместе с остальными типами. В скомпилированном классе это обычное свойство, поэтому его видит всё, что не проходит через проверку типов: вызывающий код на обычном JavaScript, JSON.stringify, Object.keys и даже собственная запись TypeScript через квадратные скобки, которая разрешена как намеренная лазейка.

class Session {
    private token = "abc123";
    userId = 7;
}

const s = new Session();
console.log(s["token"]);           // abc123: bracket access skips the check
console.log(Object.keys(s));       // [ 'token', 'userId' ]
console.log(JSON.stringify(s));    // {"token":"abc123","userId":7}

Для задачи, ради которой существует private, этого достаточно: сообщить другим разработчикам (и вашему редактору), что член это деталь реализации. Это не граница безопасности, и поле private окажется в логах и ответах JSON, если вы сами его не уберёте.

Поля #private: соблюдаются во время выполнения

В JavaScript есть собственные приватные поля, которые пишутся через #. Их соблюдает движок: вне класса obj.#field даже не является корректным синтаксисом, а поле не показывается в Object.keys, JSON.stringify или console.log.

class Session {
    #token = "abc123";
    userId = 7;

    constructor(token: string) {
        this.#token = token;
    }

    matches(t: string): boolean {
        return this.#token === t;
    }

    static isSession(x: object): boolean {
        return #token in x; // brand check: was x made by this class?
    }
}

const s = new Session("xyz");
console.log(s.matches("xyz"));     // true
console.log(Object.keys(s));       // [ 'userId' ]
console.log(JSON.stringify(s));    // {"userId":7}
console.log(s);                    // Session { userId: 7 }
console.log(Session.isSession(s), Session.isSession({ userId: 7 })); // true false

Запись s.#token вне класса это ошибка TS18013 (Property '#token' is not accessible outside class 'Session' because it has a private identifier), и в отличие от случая с private обойти её нельзя и во время выполнения. Правила времени выполнения описаны в разделе приватные поля в JavaScript.

private или #private: что использовать

Используйте #private, когда данные должны оставаться приватными во время выполнения (токены, внутреннее состояние, которое пользователи библиотеки не должны трогать) или когда нужно, чтобы JSON.stringify их пропускал. Используйте private, когда цель только в чистом публичном API, когда фреймворку нужно читать поле через рефлексию или чтобы соответствовать существующему стилю кодовой базы. Не сочетайте их: private #x это ошибка TS18010 (An accessibility modifier cannot be used with a private identifier).

protected и подклассы

Член protected доступен внутри класса и в любом классе, который его расширяет, но не через экземпляры снаружи.

class Shape {
    protected sides: number;

    constructor(sides: number) {
        this.sides = sides;
    }
}

class Polygon extends Shape {
    describe(): string {
        return `${this.sides} sides`; // fine: subclass
    }
}

const hex = new Polygon(6);
console.log(hex.describe()); // 6 sides

// @ts-expect-error: Property 'sides' is protected and only accessible within class 'Shape' and its subclasses.
console.log(hex.sides); // 6: like private, protected is not enforced at runtime

Одно правило удивляет. Внутри Polygon можно читать sides у this или у другого Polygon, но не у обычного Shape, переданного параметром: other.sides при other: Shape это ошибка TS2446 (Property 'sides' is protected and only accessible through an instance of class 'Polygon'. This is an instance of class 'Shape'.). Подкласс может обращаться к защищённым членам только тех объектов, которые принадлежат его собственной ветви иерархии.

Подкласс может сделать защищённый член публичным, переобъявив его, но не может сделать публичный член защищённым или приватным. Переобъявите его с инициализатором (public override sides = 6) или только как тип (declare public sides: number). Простое public sides: number; отвергается с TS2564 и TS2612, потому что при современных полях классов оно сбросило бы унаследованное значение в undefined после возврата из super().

readonly

readonly запрещает переприсваивание после создания объекта. Поле можно задать в объявлении или в конструкторе; любое более позднее присваивание это ошибка TS2540.

class Order {
    readonly id: string;
    readonly items: string[] = [];

    constructor(id: string) {
        this.id = id; // allowed: inside the constructor
    }
}

const order = new Order("A-17");
order.items.push("book"); // allowed: readonly is shallow
console.log(order);       // Order { id: 'A-17', items: [ 'book' ] }

// @ts-expect-error: Cannot assign to 'id' because it is a read-only property.
order.id = "B-1";
console.log(order.id);    // B-1: nothing stops it at runtime

Здесь видны два ограничения. readonly поверхностный: массив нельзя заменить, но его содержимое может меняться (чтобы запретить push, типизируйте его как readonly string[]). И как private, он исчезает во время выполнения, поэтому присваивание, которое отверг компилятор, всё равно выполнилось. Для значения, которое не должно меняться во время выполнения, используйте Object.freeze или геттер без сеттера. Readonly<T> и readonly-массивы описаны на странице о readonly.

readonly сочетается с модификаторами доступа: private readonly cache = new Map<string, number>() это распространённый приём для поля, которое внутреннее и никогда не переприсваивается.

Частые ошибки

• Считать private защитой. Во время выполнения его нет. Используйте #field для данных, которые должны оставаться скрытыми, и никогда не отправляйте объект с секретами прямо в JSON.stringify.
• Писать public везде. Это значение по умолчанию; его добавление ничего не меняет.
• Использовать protected для всего «внутреннего». Если ни одному подклассу это не нужно, private оставляет поверхность меньше.
• Ожидать, что readonly заморозит вложенные данные. Он только запрещает переприсваивать само свойство.