Access Modifiers ב-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 מסביר אותה.

מה כל מגדיר מאפשר

המגדירים עובדים על שדות, מתודות, getters ו-setters, בנאים ו-parameter properties (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: במה להשתמש

השתמשו ב-#private כשהמידע חייב להישאר פרטי בזמן ריצה (טוקנים, מצב פנימי שמשתמשי ספרייה לא אמורים לגעת בו) או כשאתם רוצים ש-JSON.stringify ישמיט אותו. השתמשו ב-private כשהמטרה היא רק API ציבורי נקי, כש-framework צריך לקרוא את השדה בצורה רפלקטיבית, או כדי להתאים לסגנון הקיים של בסיס הקוד. אל תשלבו ביניהם: 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 אפשר לקרוא את sides על this או על Polygon אחר, אבל לא על Shape רגיל שמועבר כפרמטר: other.sides כש-other: Shape היא השגיאה TS2446 (Property 'sides' is protected and only accessible through an instance of class 'Polygon'. This is an instance of class 'Shape'.). תת-מחלקה יכולה להגיע לאיברים מוגנים רק של אובייקטים ששייכים לענף שלה בהיררכיה.

תת-מחלקה יכולה להפוך איבר מוגן לציבורי על ידי הצהרה מחדש, אבל היא לא יכולה להפוך איבר ציבורי למוגן או לפרטי. הצהירו עליו מחדש עם ערך התחלתי (public override sides = 6) או כטיפוס בלבד (declare public sides: number). public sides: number; חשוף נדחה עם TS2564 ו-TS2612, כי עם class fields מודרניים הוא היה מאפס את הערך שנורש ל-undefined אחרי ש-super() מסתיים.

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 יקפיא מידע מקונן. הוא רק מונע השמה מחדש של המאפיין עצמו.