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 MixinConcepts 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 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 originale
Usern'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
// 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
// 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
// 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 sources | Ne peut hériter que d'une seule classe parente | Peut en empiler un nombre quelconque |
| Degré de couplage | Fort couplage entre la sous-classe et la classe parente | Chaque Mixin est indépendant, faible couplage |
| Granularité de réutilisation | Réutiliser les capacités de toute la classe | Réutiliser une seule fonctionnalité à la demande |
| Sûreté de typage | Prise en charge native | Doit être garanti via des contraintes génériques |
| Scénarios applicables | Relation "is-a" forte | Pré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