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 一节会解释原因。

每个修饰符允许什么

这些修饰符可以用在字段、方法、getter 和 setter、构造函数以及参数属性（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：该用哪个

当数据在运行时也必须保持私有（令牌、库的使用者不能碰的内部状态），或者你希望 JSON.stringify 忽略它时，用 #private。当目标只是一个干净的公共 API、某个框架需要通过反射读取字段，或者要和代码库已有风格保持一致时，用 private。不要把两者混用：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 内部，你可以读取 this 或另一个 Polygon 上的 sides，但不能读取作为参数传入的普通 Shape 上的：当 other: Shape 时，other.sides 会报错 TS2446（Property 'sides' is protected and only accessible through an instance of class 'Polygon'. This is an instance of class 'Shape'.）。子类只能访问属于它自己这一支继承层级的对象上的 protected 成员。

子类可以通过重新声明把 protected 成员变成 public，但不能把 public 成员变成 protected 或 private。重新声明时要么带初始值（public override sides = 6），要么只声明类型（declare public sides: number）。光写一个 public sides: number; 会被 TS2564 和 TS2612 拒绝，因为在现代的类字段语义下，它会在 super() 返回后把继承来的值重置为 undefined。

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 是浅层的：数组本身不能被替换，但它的内容可以改变（把类型写成 readonly string[] 才能禁止 push）。而且和 private 一样，它在运行时会消失，所以被编译器拒绝的那次赋值仍然执行了。对于运行时也绝不能改变的值，请使用 Object.freeze 或只有 getter 没有 setter 的属性。readonly 那一页会讲到 Readonly<T> 和只读数组。

readonly 可以和访问修饰符组合使用：private readonly cache = new Map<string, number>() 是一种常见写法，用于既属于内部、又永远不会被重新赋值的字段。

常见错误

• 把 private 当成安全措施。 它在运行时就没了。必须隐藏的数据请用 #field，也绝不要把带有机密信息的对象直接交给 JSON.stringify。
• 到处写 public。 它本来就是默认值，加上去什么也不会改变。
• 凡是“内部”的东西都用 protected。 如果没有子类需要它，用 private 可以让暴露面更小。
• 以为 readonly 会冻结嵌套数据。 它只阻止对属性本身重新赋值。