Classe abstraite en TypeScript : méthodes, propriétés, vs interface

Une classe abstraite est une classe de base marquée abstract. Elle ne peut pas être créée avec new, et elle peut déclarer des méthodes abstract sans corps, que chaque sous-classe doit implémenter.

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 partage describe() avec toutes ses sous-classes et oblige chacune à fournir area(). Le type Shape[] accepte n'importe quel mélange de sous-classes.

Une classe abstraite ne peut pas être instanciée

Appeler new sur une classe abstraite est une erreur de compilation, car l'objet aurait des méthodes sans implémentation :

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

C'est une règle de compilation. abstract est effacé de la sortie : le Shape émis est une classe JavaScript ordinaire, et du code JavaScript non typé pourrait toujours appeler new Shape(). Quand une bibliothèque a besoin d'une protection à l'exécution, le constructeur peut vérifier 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

Méthodes et propriétés abstraites

Une sous-classe doit implémenter chaque membre abstrait, ou être elle-même abstraite. En oublier un provoque l'erreur TS2515, du genre Non-abstract class 'Square' does not implement inherited abstract member area from class 'Shape', ou TS2654, qui les liste tous quand plusieurs manquent.

Les champs, les getters et les méthodes peuvent tous être abstraits, et ils peuvent être 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());

Une méthode abstraite n'a pas de corps ; en écrire un provoque l'erreur TS1245 (Method 'x' cannot have an implementation because it is marked abstract). Une classe abstraite n'est pas obligée d'avoir des membres abstraits : abstract seul se contente d'empêcher l'instanciation directe.

Le motif template method

La raison la plus courante d'écrire une classe abstraite : la classe de base fixe l'ordre des étapes, et chaque sous-classe remplit les étapes qui varient.

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

Les classes abstraites peuvent être génériques, comme ici, pour que chaque sous-classe choisisse le type des enregistrements.

Types de constructeurs abstraits

typeof Shape pour une classe abstraite est un constructeur que vous n'avez pas le droit d'appeler : un paramètre typé typeof Shape ne peut donc pas faire new c(). Quand une fonction doit accepter des classes abstraites (par exemple pour les enregistrer ou vérifier instanceof), typez-la avec une signature de construction abstraite :

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 accepte les classes abstraites comme concrètes ; un simple new n'accepte que les concrètes.

Classe abstraite ou interface

La règle empirique : une interface quand vous avez seulement besoin de décrire une forme (le cas le plus fréquent, qui fonctionne aussi pour les littéraux objet), une classe abstraite quand les sous-classes partagent une vraie implémentation et que vous voulez que le compilateur les force à combler les manques. Les deux se combinent bien : une interface pour le contrat public, une classe abstraite comme base pratique qui l'implémente. Voir interface ou type pour l'autre comparaison courante.

Erreurs fréquentes

• Utiliser une classe abstraite là où une interface suffirait. Si la classe de base ne contient aucun code, c'est une interface avec un poids supplémentaire à l'exécution et une limite d'héritage simple.
• Essayer static abstract. Ce n'est pas autorisé. Les membres statiques ne peuvent pas être abstraits.
• S'attendre à une erreur à l'exécution en faisant new sur une classe abstraite. Il n'y en a aucune, sauf si vous écrivez la vérification de new.target.
• Appeler une méthode abstraite depuis le constructeur de base. Elle s'exécute avant l'initialisation des champs de la sous-classe, donc l'implémentation les voit à undefined.