Abstract class trong TypeScript: method và interface

Abstract class (lớp trừu tượng) là lớp cơ sở được đánh dấu abstract. Nó không thể được tạo bằng new, và có thể khai báo các phương thức abstract không có thân hàm, mà mọi lớp con đều phải triển khai.

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 chia sẻ describe() cho mọi lớp con và buộc từng lớp phải cung cấp area(). Kiểu Shape[] chứa được bất kỳ tổ hợp lớp con nào.

Không thể tạo instance từ abstract class

Gọi new trên một abstract class là lỗi biên dịch, vì đối tượng tạo ra sẽ có những phương thức không có phần triển khai:

// 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.

Đây là quy tắc lúc biên dịch. abstract bị xóa khỏi đầu ra, nên Shape được sinh ra là một lớp JavaScript bình thường, và code JavaScript không có kiểu vẫn có thể gọi new Shape(). Khi một thư viện cần chốt chặn lúc runtime, hàm khởi tạo có thể kiểm tra 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

Phương thức và thuộc tính abstract

Lớp con phải triển khai mọi thành viên abstract, nếu không thì chính nó cũng phải là abstract. Thiếu một thành viên sẽ gây lỗi TS2515, có nội dung kiểu Non-abstract class 'Square' does not implement inherited abstract member area from class 'Shape', hoặc TS2654 liệt kê tất cả khi thiếu nhiều thành viên.

Field, getter và phương thức đều có thể là abstract, và có thể là 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());

Phương thức abstract không có thân hàm; viết thân hàm cho nó sẽ gây lỗi TS1245 (Method 'x' cannot have an implementation because it is marked abstract). Một abstract class không nhất thiết phải có thành viên abstract nào: chỉ riêng abstract đã ngăn việc tạo instance trực tiếp.

Mẫu template method

Lý do phổ biến nhất để viết abstract class: lớp cơ sở cố định thứ tự các bước, còn mỗi lớp con điền vào những bước thay đổi.

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 } ]

Abstract class có thể là generic như ở đây, để mỗi lớp con tự chọn kiểu bản ghi.

Kiểu hàm khởi tạo abstract

Với một abstract class, typeof Shape là một hàm khởi tạo mà bạn không được phép gọi, nên một tham số có kiểu typeof Shape không thể làm new c(). Khi một hàm cần nhận abstract class (ví dụ để đăng ký chúng hoặc kiểm tra instanceof), hãy định kiểu bằng abstract construct signature:

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 nhận cả lớp abstract lẫn lớp cụ thể; new thông thường chỉ nhận lớp cụ thể.

Abstract class và interface

Quy tắc chung: dùng interface khi bạn chỉ cần mô tả cấu trúc (trường hợp phổ biến nhất, và áp dụng được cho cả object literal), dùng abstract class khi các lớp con chia sẻ phần triển khai thật và bạn muốn trình biên dịch buộc chúng điền vào phần còn thiếu. Hai thứ này kết hợp tốt với nhau: interface cho hợp đồng công khai, abstract class làm một lớp cơ sở tiện dụng triển khai interface đó. Xem interface và type cho một phép so sánh thường gặp khác.

Lỗi thường gặp

• Dùng abstract class ở nơi interface là đủ. Nếu lớp cơ sở không có code, nó chỉ là một interface nặng thêm lúc runtime và bị giới hạn kế thừa đơn.
• Thử dùng static abstract. Không được phép. Thành viên static không thể là abstract.
• Chờ lỗi runtime khi gọi new trên abstract class. Sẽ không có lỗi nào, trừ khi bạn tự viết phần kiểm tra new.target.
• Gọi phương thức abstract từ hàm khởi tạo của lớp cơ sở. Nó chạy trước khi các field của lớp con được khởi tạo, nên phần triển khai sẽ thấy chúng là undefined.