מחלקה אבסטרקטית ב-TypeScript: מתודות, מאפיינים ו-interface

מחלקה אבסטרקטית היא מחלקת בסיס שמסומנת ב-abstract. אי אפשר ליצור אותה עם new, והיא יכולה להצהיר על מתודות abstract בלי גוף, שכל תת-מחלקה חייבת לממש.

abstract class Shape {
    abstract area(): number; // no body: subclasses provide it

    describe(): string {
        // Concrete methods can call abstract ones.
        return `${this.constructor.name} with area ${this.area().toFixed(2)}`;
    }
}

class Circle extends Shape {
    constructor(private r: number) {
        super();
    }
    area(): number {
        return Math.PI * this.r ** 2;
    }
}

class Rect extends Shape {
    constructor(private w: number, private h: number) {
        super();
    }
    area(): number {
        return this.w * this.h;
    }
}

const shapes: Shape[] = [new Circle(1), new Rect(2, 3)];
for (const s of shapes) console.log(s.describe());
// Circle with area 3.14
// Rect with area 6.00

Shape משתפת את describe() עם כל תתי-המחלקות ומחייבת כל אחת מהן לספק את area(). הטיפוס Shape[] מחזיק כל שילוב של תתי-מחלקות.

אי אפשר ליצור מופע של מחלקה אבסטרקטית

קריאה ל-new על מחלקה אבסטרקטית היא שגיאת קומפילציה, כי לאובייקט היו מתודות בלי מימוש:

// This does not compile: Shape is abstract.
abstract class Shape {
    abstract area(): number;
}

const s = new Shape();
console.log(s.area());

index.ts(6,11): error TS2511: Cannot create an instance of an abstract class.

זה כלל של זמן קומפילציה. abstract נמחק מהפלט, כך ש-Shape שנוצרת היא מחלקת JavaScript רגילה, וקוד JavaScript בלי טיפוסים עדיין יכול לקרוא ל-new Shape(). כשספרייה צריכה הגנה בזמן ריצה, הבנאי יכול לבדוק את new.target:

abstract class Plugin {
    constructor() {
        if (new.target === Plugin) {
            throw new TypeError("Plugin is abstract; extend it");
        }
    }
    abstract run(): string;
}

class Hello extends Plugin {
    run(): string {
        return "hello";
    }
}

console.log(new Hello().run()); // hello

מתודות ומאפיינים אבסטרקטיים

תת-מחלקה חייבת לממש כל איבר אבסטרקטי, או להיות אבסטרקטית בעצמה. אם אחד חסר, מקבלים את השגיאה TS2515, שנראית כמו Non-abstract class 'Square' does not implement inherited abstract member area from class 'Shape', או TS2654 שמפרטת את כולם כשחסרים כמה.

שדות, getters ומתודות יכולים כולם להיות אבסטרקטיים, והם יכולים להיות protected:

abstract class Report {
    abstract readonly title: string;          // abstract property
    protected abstract rows(): string[];      // only for subclasses

    abstract get footer(): string;            // abstract getter

    render(): string {
        return [this.title, ...this.rows(), this.footer].join("\n");
    }
}

class SalesReport extends Report {
    readonly title = "Sales Q1";

    protected rows(): string[] {
        return ["Jan: 120", "Feb: 95", "Mar: 140"];
    }

    get footer(): string {
        return "Total: 355";
    }
}

console.log(new SalesReport().render());

למתודה אבסטרקטית אין גוף; כתיבת גוף היא השגיאה TS1245 (Method 'x' cannot have an implementation because it is marked abstract). מחלקה אבסטרקטית לא חייבת לכלול איברים אבסטרקטיים בכלל: abstract לבדו רק מונע יצירת מופע ישירה.

תבנית template method

הסיבה הנפוצה ביותר לכתוב מחלקה אבסטרקטית: מחלקת הבסיס קובעת את סדר השלבים, וכל תת-מחלקה ממלאת את השלבים שמשתנים.

abstract class Importer<T> {
    // The algorithm lives here, once.
    import(raw: string): T[] {
        const lines = raw.trim().split("\n");
        const records = lines.map((line) => this.parse(line));
        return records.filter((r) => this.isValid(r));
    }

    protected abstract parse(line: string): T;

    // A default subclasses may override.
    protected isValid(_record: T): boolean {
        return true;
    }
}

type Person = { name: string; age: number };

class PersonImporter extends Importer<Person> {
    protected parse(line: string): Person {
        const [name, age] = line.split(",");
        return { name, age: Number(age) };
    }

    protected override isValid(p: Person): boolean {
        return !Number.isNaN(p.age);
    }
}

console.log(new PersonImporter().import("Ada,36\nBob,x\nCy,29"));
// [ { name: 'Ada', age: 36 }, { name: 'Cy', age: 29 } ]

מחלקות אבסטרקטיות יכולות להיות גנריות, כמו כאן, כך שכל תת-מחלקה בוחרת את טיפוס הרשומה.

טיפוסי בנאי אבסטרקטיים

typeof Shape של מחלקה אבסטרקטית הוא בנאי שאסור לקרוא לו, ולכן פרמטר מטיפוס typeof Shape לא יכול לעשות new c(). כשפונקציה צריכה לקבל מחלקות אבסטרקטיות (למשל כדי לרשום אותן או לבדוק instanceof), תנו לה טיפוס עם חתימת בנייה אבסטרקטית:

abstract class Animal {
    abstract sound(): string;
}
class Dog extends Animal {
    sound(): string {
        return "woof";
    }
}

type AbstractCtor<T> = abstract new (...args: never[]) => T;
type Ctor<T> = new () => T;

function isKind<T>(value: unknown, kind: AbstractCtor<T>): value is T {
    return value instanceof kind;
}

function create<T>(kind: Ctor<T>): T {
    return new kind();
}

const pet = create(Dog);     // fine: Dog is concrete
console.log(pet.sound());    // woof
console.log(isKind(pet, Animal), isKind("cat", Animal)); // true false
// create(Animal) is an error: Animal is abstract

abstract new מקבל גם מחלקות אבסטרקטיות וגם מחלקות קונקרטיות; new רגיל מקבל רק קונקרטיות.

מחלקה אבסטרקטית מול interface

כלל האצבע: interface כשצריך רק לתאר מבנה (המקרה הנפוץ ביותר, והוא עובד גם עם אובייקטים ליטרליים), ומחלקה אבסטרקטית כשתתי-המחלקות חולקות מימוש אמיתי ורוצים שהקומפיילר יחייב אותן להשלים את החסר. השתיים משתלבות היטב: interface לחוזה הציבורי, ומחלקה אבסטרקטית כבסיס נוח אחד שמממש אותו. ראו interface מול type להשוואה הנפוצה השנייה.

טעויות נפוצות

• שימוש במחלקה אבסטרקטית כש-interface מספיקה. אם אין קוד במחלקת הבסיס, היא בעצם interface עם משקל נוסף בזמן ריצה ומגבלה של ירושה יחידה.
• ניסיון לכתוב static abstract. אסור. איברים סטטיים לא יכולים להיות אבסטרקטיים.
• ציפייה לשגיאת זמן ריצה מ-new על מחלקה אבסטרקטית. אין כזו, אלא אם כותבים את הבדיקה של new.target.
• קריאה למתודה אבסטרקטית מהבנאי של מחלקת הבסיס. היא רצה לפני שהשדות של תת-המחלקה מאותחלים, ולכן המימוש רואה אותם כ-undefined.