Access modifier trong TypeScript: public, private, protected

TypeScript có ba access modifier (từ khóa phạm vi truy cập) cho thành viên của lớp: public (mặc định), protected và private. Chúng quy định nơi một thành viên có thể được dùng, và trình biên dịch sẽ báo lỗi mọi truy cập từ sai chỗ.

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);

Dòng cuối cùng là lỗi biên dịch, nhưng hãy xem nó in ra gì khi vẫn chạy: 123-45-6789. Đó là điều quan trọng nhất của trang này, và phần private sẽ giải thích.

Mỗi modifier cho phép gì

Các modifier dùng được cho field, phương thức, getter và setter, hàm khởi tạo và parameter property (constructor(private id: string)). Viết public là không bắt buộc, và nhiều codebase bỏ nó đi.

private là kiểm tra lúc biên dịch

TypeScript xóa private cùng với phần còn lại của kiểu. Lớp sau khi biên dịch có một thuộc tính bình thường, nên mọi thứ không đi qua bộ kiểm tra kiểu đều thấy nó: code JavaScript thuần, JSON.stringify, Object.keys, và ngay cả cú pháp ngoặc vuông của chính TypeScript, vốn được cho phép như một lối thoát có chủ đích.

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}

Điều đó ổn với mục đích của private: báo cho các lập trình viên khác (và trình soạn thảo) biết rằng một thành viên là chi tiết triển khai nội bộ. Nó không phải là ranh giới bảo mật, và field private sẽ xuất hiện trong log và response JSON nếu bạn không tự loại bỏ nó.

Field #private: áp dụng lúc runtime

JavaScript có private field riêng, viết bằng #. Engine áp dụng chúng: bên ngoài lớp, obj.#field thậm chí không phải cú pháp hợp lệ, và field này không xuất hiện trong Object.keys, JSON.stringify hay 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

Viết s.#token bên ngoài lớp gây lỗi TS18013 (Property '#token' is not accessible outside class 'Session' because it has a private identifier), và khác với trường hợp private, lúc runtime cũng không có cách nào lách được. Xem private field trong JavaScript để biết các quy tắc lúc runtime.

private và #private: nên dùng cái nào

Dùng #private khi dữ liệu phải giữ riêng tư lúc runtime (token, trạng thái nội bộ mà người dùng thư viện không được đụng vào) hoặc khi bạn muốn JSON.stringify bỏ qua nó. Dùng private khi mục tiêu chỉ là một API công khai gọn gàng, khi framework cần đọc field bằng reflection, hoặc để khớp với phong cách sẵn có của codebase. Đừng kết hợp hai cách: private #x gây lỗi TS18010 (An accessibility modifier cannot be used with a private identifier).

protected và lớp con

Thành viên protected dùng được bên trong lớp và trong mọi lớp kế thừa nó, nhưng không dùng được trên instance từ bên ngoài.

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

Có một quy tắc khiến nhiều người bất ngờ. Bên trong Polygon, bạn có thể đọc sides trên this hoặc trên một Polygon khác, nhưng không được trên một Shape thông thường truyền vào làm tham số: other.sides với other: Shape gây lỗi TS2446 (Property 'sides' is protected and only accessible through an instance of class 'Polygon'. This is an instance of class 'Shape'.). Lớp con chỉ được truy cập thành viên protected của những đối tượng thuộc nhánh của chính nó trong hệ thống lớp.

Lớp con có thể biến một thành viên protected thành public bằng cách khai báo lại, nhưng không thể biến thành viên public thành protected hay private. Khai báo lại kèm giá trị khởi tạo (public override sides = 6) hoặc chỉ khai báo kiểu (declare public sides: number). Một dòng public sides: number; trống trơn sẽ bị từ chối với TS2564 và TS2612, vì với class field hiện đại, nó sẽ đặt lại giá trị kế thừa thành undefined sau khi super() trả về.

readonly

readonly chặn việc gán lại sau khi khởi tạo. Field có thể được gán khi khai báo hoặc trong hàm khởi tạo; mọi lần gán sau đó đều gây lỗi 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

Ở đây có hai giới hạn. readonly chỉ có tác dụng nông: mảng không thể bị thay thế, nhưng nội dung của nó vẫn thay đổi được (đặt kiểu readonly string[] để chặn push). Và giống private, nó biến mất lúc runtime, nên phép gán mà trình biên dịch đã từ chối vẫn được chạy. Với giá trị không được phép thay đổi lúc runtime, hãy dùng Object.freeze hoặc một getter không có setter. Trang về readonly nói về Readonly<T> và mảng readonly.

readonly kết hợp được với các access modifier: private readonly cache = new Map<string, number>() là mẫu phổ biến cho một field nội bộ và không bao giờ bị gán lại.

Lỗi thường gặp

• Coi private là bảo mật. Nó biến mất lúc runtime. Dùng #field cho dữ liệu cần được ẩn, và đừng bao giờ đưa thẳng một đối tượng chứa thông tin bí mật vào JSON.stringify.
• Viết public ở mọi nơi. Đó là mặc định; thêm vào cũng không thay đổi gì.
• Dùng protected cho mọi thứ "nội bộ". Nếu không có lớp con nào cần, private giữ phạm vi công khai nhỏ hơn.
• Nghĩ rằng readonly đóng băng cả dữ liệu lồng nhau. Nó chỉ chặn việc gán lại chính thuộc tính đó.