Access Modifier TypeScript: public, private, protected

TypeScript punya tiga access modifier untuk member class: public (default), protected, dan private. Modifier ini mengatur di mana sebuah member boleh dipakai, dan compiler melaporkan setiap akses dari tempat yang salah.

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

Baris terakhir adalah error kompilasi, tetapi lihat apa yang tetap tercetak saat kode dijalankan: 123-45-6789. Itulah fakta terpenting di halaman ini, dan bagian private menjelaskannya.

Apa yang Diizinkan Setiap Modifier

Modifier ini berlaku untuk field, method, getter dan setter, constructor, serta parameter property (constructor(private id: string)). Menulis public bersifat opsional, dan banyak codebase tidak menuliskannya.

private Hanya Diperiksa Saat Kompilasi

TypeScript menghapus private bersama tipe lainnya. Class hasil kompilasi berisi property biasa, jadi apa pun yang tidak melewati pemeriksa tipe bisa melihatnya: pemanggil JavaScript biasa, JSON.stringify, Object.keys, bahkan notasi kurung siku milik TypeScript sendiri, yang sengaja diizinkan sebagai jalan pintas.

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}

Itu tidak masalah untuk tujuan private yang sebenarnya: memberi tahu developer lain (dan editormu) bahwa sebuah member adalah detail implementasi. Ini bukan batas keamanan, dan field private akan ikut masuk ke log dan respons JSON kecuali kamu membuangnya sendiri.

Field #private: Ditegakkan Saat Runtime

JavaScript punya field private sendiri, yang ditulis dengan #. Engine yang menegakkannya: di luar class, obj.#field bahkan bukan sintaks yang valid, dan field itu tidak muncul di Object.keys, JSON.stringify, maupun 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

Menulis s.#token di luar class menghasilkan error TS18013 (Property '#token' is not accessible outside class 'Session' because it has a private identifier), dan tidak seperti private, tidak ada cara mengakalinya saat runtime juga. Lihat field private di JavaScript untuk aturan runtime-nya.

private vs #private: Mana yang Dipakai

Pakai #private kalau data harus tetap private saat runtime (token, state internal yang tidak boleh disentuh pengguna sebuah library) atau kalau kamu ingin JSON.stringify melewatinya. Pakai private kalau tujuannya hanya API publik yang rapi, kalau sebuah framework perlu membaca field itu secara reflektif, atau untuk menyamakan dengan gaya codebase yang sudah ada. Jangan menggabungkan keduanya: private #x menghasilkan error TS18010 (An accessibility modifier cannot be used with a private identifier).

protected dan Subclass

Member protected tersedia di dalam class dan di setiap class yang mewarisinya, tetapi tidak lewat instance dari luar.

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

Ada satu aturan yang sering mengejutkan. Di dalam Polygon, kamu bisa membaca sides pada this atau pada Polygon lain, tetapi tidak pada Shape biasa yang dikirim sebagai parameter: other.sides dengan other: Shape menghasilkan error TS2446 (Property 'sides' is protected and only accessible through an instance of class 'Polygon'. This is an instance of class 'Shape'.). Subclass hanya boleh menjangkau member protected dari objek yang berada di cabang hierarkinya sendiri.

Subclass bisa membuat member protected menjadi public dengan mendeklarasikannya ulang, tetapi tidak bisa membuat member public menjadi protected atau private. Deklarasikan ulang dengan nilai awal (public override sides = 6) atau hanya sebagai tipe (declare public sides: number). public sides: number; saja akan ditolak dengan TS2564 dan TS2612, karena dengan class field modern, deklarasi itu akan mengembalikan nilai warisan menjadi undefined setelah super() selesai.

readonly

readonly mencegah penugasan ulang setelah objek dibuat. Field bisa diberi nilai di deklarasinya atau di constructor; penugasan apa pun setelah itu menghasilkan error 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

Ada dua batasan yang terlihat di sini. readonly bersifat dangkal: array-nya tidak bisa diganti, tetapi isinya bisa berubah (beri tipe readonly string[] untuk mencegah push). Dan seperti private, modifier ini hilang saat runtime, jadi penugasan yang ditolak compiler tetap dijalankan. Untuk nilai yang tidak boleh berubah saat runtime, pakai Object.freeze atau getter tanpa setter. Halaman readonly membahas Readonly<T> dan array readonly.

readonly bisa digabung dengan access modifier: private readonly cache = new Map<string, number>() adalah pola umum untuk field yang bersifat internal dan tidak pernah diberi nilai ulang.

Kesalahan Umum

• Menganggap private sebagai keamanan. Modifier ini hilang saat runtime. Pakai #field untuk data yang harus tetap tersembunyi, dan jangan pernah mengirim objek berisi rahasia langsung ke JSON.stringify.
• Menulis public di mana-mana. Itu sudah default; menambahkannya tidak mengubah apa pun.
• Memakai protected untuk semua hal yang "internal". Kalau tidak ada subclass yang membutuhkannya, private membuat permukaan API lebih kecil.
• Mengira readonly membekukan data bersarang. Modifier ini hanya mencegah penugasan ulang property itu sendiri.