TypeScript Erişim Belirleyiciler: public, private, protected

TypeScript'te sınıf üyeleri için üç erişim belirleyici vardır: public (varsayılan), protected ve private. Bir üyenin nerede kullanılabileceğini belirlerler ve derleyici yanlış yerden yapılan her erişimi bildirir.

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

Son satır bir derleme hatasıdır, ama yine de çalıştırıldığında ne yazdırdığına bakın: 123-45-6789. Bu sayfadaki en önemli bilgi budur ve private bölümü bunu açıklıyor.

Her Belirleyici Neye İzin Verir

Belirleyiciler alanlarda, metotlarda, getter ve setter'larda, constructor'larda ve parametre özelliklerinde (constructor(private id: string)) çalışır. public yazmak isteğe bağlıdır ve birçok kod tabanı onu hiç yazmaz.

private Bir Derleme Zamanı Kontrolüdür

TypeScript, private belirleyicisini diğer tiplerle birlikte siler. Derlenmiş sınıfta sıradan bir özellik vardır; bu yüzden tip denetleyicisinden geçmeyen her şey onu görür: düz JavaScript çağıranları, JSON.stringify, Object.keys ve hatta bilinçli bir kaçış yolu olarak izin verilen TypeScript'in kendi köşeli parantez gösterimi.

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}

Bu, private belirleyicisinin asıl amacı için sorun değildir: diğer geliştiricilere (ve editörünüze) bir üyenin bir implementasyon ayrıntısı olduğunu söylemek. Bir güvenlik sınırı değildir ve siz kendiniz çıkarmadıkça private bir alan loglara ve JSON yanıtlarına girer.

#private Alanlar: Çalışma Zamanında Korunur

JavaScript'in # ile yazılan kendi private alanları vardır. Bunları motor korur: sınıfın dışında obj.#field geçerli bir sözdizimi bile değildir ve alan Object.keys, JSON.stringify ya da console.log çıktısında görünmez.

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ınıfın dışında s.#token yazmak TS18013 hatasıdır (Property '#token' is not accessible outside class 'Session' because it has a private identifier) ve private durumundan farklı olarak çalışma zamanında da bunun bir yolu yoktur. Çalışma zamanı kuralları için JavaScript'te private alanlar sayfasına bakın.

private mı #private mı: Hangisini Kullanmalı

Verinin çalışma zamanında da gizli kalması gerekiyorsa (token'lar, bir kütüphanenin kullanıcılarının dokunmaması gereken iç durum) ya da JSON.stringify çıktısında yer almasını istemiyorsanız #private kullanın. Amaç yalnızca temiz bir public API ise, bir framework'ün alanı reflection ile okuması gerekiyorsa ya da kod tabanının mevcut stiline uymak istiyorsanız private kullanın. İkisini birleştirmeyin: private #x, TS18010 hatasıdır (An accessibility modifier cannot be used with a private identifier).

protected ve Alt Sınıflar

protected bir üye sınıfın içinde ve onu genişleten her sınıfta kullanılabilir, ancak dışarıdan örnekler üzerinden kullanılamaz.

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

Bir kural insanları şaşırtır. Polygon içinde sides alanını this üzerinde ya da başka bir Polygon üzerinde okuyabilirsiniz, ama parametre olarak geçirilen düz bir Shape üzerinde okuyamazsınız: other: Shape iken other.sides, TS2446 hatasıdır (Property 'sides' is protected and only accessible through an instance of class 'Polygon'. This is an instance of class 'Shape'.). Bir alt sınıf yalnızca hiyerarşide kendi dalına ait nesnelerin protected üyelerine ulaşabilir.

Bir alt sınıf, protected bir üyeyi yeniden bildirerek public yapabilir, ama public bir üyeyi protected ya da private yapamaz. Üyeyi bir başlangıç değeriyle (public override sides = 6) ya da yalnızca tip olarak (declare public sides: number) yeniden bildirin. Tek başına public sides: number; yazmak TS2564 ve TS2612 ile reddedilir, çünkü modern sınıf alanlarında bu, super() döndükten sonra miras alınan değeri undefined olarak sıfırlardı.

readonly

readonly, oluşturma işleminden sonra yeniden atamayı engeller. Alan bildiriminde ya da constructor içinde ayarlanabilir; sonraki her atama TS2540 hatasıdır.

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

Burada iki sınır ortaya çıkıyor. readonly yüzeyseldir: dizi başka bir diziyle değiştirilemez ama içeriği değişebilir (push işlemini engellemek için tipini readonly string[] yapın). Ve private gibi çalışma zamanında kaybolur, bu yüzden derleyicinin reddettiği atama yine de çalıştı. Çalışma zamanında değişmemesi gereken bir değer için Object.freeze ya da setter'ı olmayan bir getter kullanın. readonly sayfası Readonly<T> ve readonly dizileri anlatıyor.

readonly erişim belirleyicilerle birlikte kullanılabilir: private readonly cache = new Map<string, number>(), dahili olan ve hiç yeniden atanmayan bir alan için yaygın bir kalıptır.

Sık Yapılan Hatalar

• private belirleyicisini güvenlik sanmak. Çalışma zamanında yoktur. Gizli kalması gereken veriler için #field kullanın ve gizli bilgiler içeren bir nesneyi asla doğrudan JSON.stringify içine vermeyin.
• Her yere public yazmak. Zaten varsayılandır; eklemek hiçbir şeyi değiştirmez.
• "Dahili" olan her şey için protected kullanmak. Hiçbir alt sınıf ona ihtiyaç duymuyorsa private dışa açık yüzeyi daha küçük tutar.
• readonly belirleyicisinin iç içe veriyi dondurmasını beklemek. Yalnızca özelliğin kendisinin yeniden atanmasını durdurur.