TypeScriptのアクセス修飾子: public・private・protected

TypeScriptにはクラスのメンバー用のアクセス修飾子が3つあります。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

意外なルールが1つあります。Polygon の中では、this や別の Polygon の sides は読めますが、引数として渡された普通の Shape の sides は読めません。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

ここには2つの限界が表れています。readonly は浅く、配列を置き換えることはできませんが、中身は変更できます（push を禁止するには readonly string[] 型にします）。そして private と同じく実行時には消えるので、コンパイラーが拒否した代入も実行されてしまいます。実行時に変更されてはいけない値には、Object.freeze か setter のない getter を使いましょう。Readonly<T> と readonly 配列については readonly のページで扱います。

readonly はアクセス修飾子と組み合わせられます。private readonly cache = new Map<string, number>() は、内部で使い、再代入しないフィールドのよくあるパターンです。

よくある間違い

• private をセキュリティとして扱う。 実行時には消えています。隠さなければならないデータには #field を使い、秘密を含むオブジェクトをそのまま JSON.stringify に渡してはいけません。
• あらゆる場所に public を書く。 デフォルトなので、書いても何も変わりません。
• 「内部用」のものすべてに protected を使う。 必要とするサブクラスがないなら、private のほうが公開範囲を小さく保てます。
• readonly がネストしたデータを凍結すると期待する。 止めるのはプロパティそのものの再代入だけです。