Mixin TypeScript

Un Mixin est un modèle de réutilisation de code utilisé pour mélanger plusieurs modules fonctionnels indépendants dans une seule classe.

TypeScript implémente les Mixins en utilisant des fonctions génériques pour retourner des classes étendues, compensant la limitation selon laquelle l'héritage simple ne peut pas réutiliser le comportement de plusieurs sources.

Diagramme SVG : processus de composition de Mixin Background Title Mixin Composition Process Base Class User User Class Arrow to Mixin1 SerializableMixin + serialize() Arrow to Mixin2 TimestampedMixin + timestamp Arrow to Result Composition Result Extended Class Explanation Below How Mixins Work Principle Explanation 1 1. A Mixin is a function Takes a class and returns a new extended class Principle Explanation 2 2. Inheritance rather than modification Inherit through extends, without modifying the original class Principle Explanation 3 3. Stackable composition Multiple Mixins can be nested and combined Arrow labels

Concepts de base

Le cœur d'un Mixin est une fonction générique qui prend une classe de base et retourne une classe étendue.ConstructorLa contrainte de type est utilisée pour décrire "toute classe qui peut être héritée."

Exemple

// Type de constructeur : décrit toute classe instanciable
type Constructor<T = {}> = new (...args: any[]) => T;

// Fonction Mixin : prend une classe de base et retourne une nouvelle classe étendue
function Timestamped<TBase extends Constructor>(Base: TBase) {
    return class extends Base {
        createdAt = new Date();
    };
}

// Classe de base
class User {
    constructor(public name: string) {}
}

// Obtenir une nouvelle classe après le mélange
const TimestampedUser = Timestamped(User);
const user = new TimestampedUser("Alice");

console.log(user.name);                        // Alice
console.log(user.createdAt instanceof Date);   // vrai

Sortie :

Alice
true

Remarque :Un Mixin ne modifie pas la classe d'origine ; il renvoie une toute nouvelle classe étendue. La classe originaleUsern'est pas affectée.


Combiner plusieurs Mixins

L'imbrication de plusieurs fonctions Mixin vous permet d'empiler plusieurs capacités sur la même classe en séquence.

Exemple

type Constructor<T = {}> = new (...args: any[]) => T;

// Mixin 1 : ajouter un horodatage
function Timestamped<TBase extends Constructor>(Base: TBase) {
    return class extends Base {
        createdAt = new Date();
    };
}

// Mixin 2 : ajouter une sérialisation
function Serializable<TBase extends Constructor>(Base: TBase) {
    return class extends Base {
        serialize(): string {
            return JSON.stringify(this);
        }
    };
}

// Mixin 3 : ajouter la journalisation (dépend de la méthode serialize)
function Loggable<TBase extends Constructor<{ serialize(): string }>>(Base: TBase) {
    return class extends Base {
        log(): void {
            console.log("[LOG]", this.serialize());
        }
    };
}

class Product {
    constructor(public name: string, public price: number) {}
}

// Empiler trois Mixins en séquence
const AdvancedProduct = Loggable(Serializable(Timestamped(Product)));

const p = new AdvancedProduct("Phone", 999);
p.log();
console.log(p.createdAt instanceof Date);  // vrai

Sortie :

[LOG] {"name":"Phone","price":999,"createdAt":"2026-..."}
true

Mixin et interfaces

La classe renvoyée par un Mixin peut déclarer qu'elle implémente une interface, permettant aux consommateurs d'opérer sur l'objet mixé via le type d'interface sans dépendre de l'implémentation concrète.

Exemple

type Constructor<T = {}> = new (...args: any[]) => T;

// Définir une interface de capacité
interface ISerializable {
    serialize(): string;
}

interface ICloneable<T> {
    clone(): T;
}

// Mixin implémente l'interface
function Serializable<TBase extends Constructor>(Base: TBase) {
    return class extends Base implements ISerializable {
        serialize(): string {
            return JSON.stringify(this);
        }
    };
}

function Cloneable<TBase extends Constructor>(Base: TBase) {
    return class extends Base {
        clone() {
            return Object.assign(
                Object.create(Object.getPrototypeOf(this)),
                this
            );
        }
    };
}

class Article {
    constructor(public title: string, public content: string) {}
}

const RichArticle = Cloneable(Serializable(Article));

const a1 = new RichArticle("Introduction à TypeScript", "Contenu...");
const a2 = a1.clone();
a2.title = "TypeScript avancé";

console.log(a1.serialize());
// {"title":"Introduction à TypeScript","content":"Contenu..."}

console.log(a2.serialize());
// {"title":"TypeScript avancé","content":"Contenu..."}

console.log(a1.title === a2.title);  // false (modifié indépendamment après le clonage)

Sortie :

{"title":"TypeScript 入门","content":"正文内容..."}
{"title":"TypeScript 进阶","content":"正文内容..."}
false

Mixin contraint

En utilisant des contraintes génériques, vous pouvez restreindre un Mixin pour qu'il ne s'applique qu'à des classes qui remplissent des conditions spécifiques, évitant ainsi des propriétés requises manquantes à l'exécution.

Exemple

type Constructor<T = {}> = new (...args: any[]) => T;

// Contrainte : la classe de base doit avoir les propriétés id et name
type WithIdAndName = Constructor<{ id: number; name: string }>;

function Printable<TBase extends WithIdAndName>(Base: TBase) {
    return class extends Base {
        print(): void {
            console.log(`[${this.id}] ${this.name}`);
        }
    };
}

class Item {
    constructor(public id: number, public name: string) {}
}

// Correct : Item satisfait la contrainte
const PrintableItem = Printable(Item);
const item = new PrintableItem(42, "Keyboard");
item.print();  // [42] Keyboard

// Exemple d'erreur (le compilateur l'empêchera) :
// class NoId { constructor(public name: string) {} }
// const Bad = Printable(NoId); // Erreur : NoId ne possède pas la propriété id

Sortie :

[42] Keyboard

Mixin vs Héritage

Dimension Héritage (extends) Mixin
Nombre de sourcesNe peut hériter que d'une seule classe parentePeut en empiler un nombre quelconque
Degré de couplageFort couplage entre la sous-classe et la classe parenteChaque Mixin est indépendant, faible couplage
Granularité de réutilisationRéutiliser les capacités de toute la classeRéutiliser une seule fonctionnalité à la demande
Sûreté de typagePrise en charge nativeDoit être garanti via des contraintes génériques
Scénarios applicablesRelation "is-a" fortePréoccupations transversales (journalisation, sérialisation, mise en cache, etc.)

Résumé

  • Motif central :Un Mixin est une fonction générique qui prend une classe de base et renvoie une classe étendue,Constructor<T>est le type de contrainte standard
  • Empilement des capacités :L'imbrication de plusieurs fonctions Mixin permet de combiner plusieurs capacités dans une même classe
  • Intégration des interfaces :La classe retournée par un Mixin peut implémenter des interfaces ; les consommateurs n'ont besoin de dépendre que des interfaces plutôt que des classes concrètes
  • Contraintes génériques :Grâce aux contraintes,TBasevous pouvez limiter le champ d'application d'un Mixin et empêcher une utilisation incorrecte au moment de la compilation
  • Scénarios d'application :Journalisation, sérialisation, clonage, horodatages et autres préoccupations transversales ; mieux que l'héritage à plusieurs niveaux
Autres extensions