Patrons de conception TypeScript

Les patrons de conception sont des solutions éprouvées en développement logiciel qui nous aident à écrire du code maintenable et extensible.

Le système de types de TypeScript permet d'implémenter de nombreux patrons de conception classiques de manière sûre en termes de types.


Diagramme SVG : Classification des patrons de conception Background Title Design Pattern Classification Creational Creational Patterns Factory | Singleton | Builder Structural Structural Patterns Decorator | Adapter | Proxy Behavioral Behavioral Patterns Observer | Strategy | Command TypeScript-specific TypeScript-specific Patterns Type-safe dependency injection | Generic factory | Conditional type selection Advantages TypeScript advantages: compile-time type checking + IDE IntelliSense + runtime performance

Pourquoi avons-nous besoin de patrons de conception ?

Les patrons de conception sont une expérience d'organisation de code résumée par nos prédécesseurs, et peuvent résoudre des problèmes courants de conception logicielle.

L'utilisation des patrons de conception rend le code plus facile à comprendre et à maintenir, et facilite également la collaboration en équipe.

Le système de types de TypeScript rend ces patrons plus robustes, et les erreurs peuvent être détectées à la compilation.

Concept:Les patrons de conception sont des solutions réutilisables à des problèmes courants en conception logicielle, et sont un résumé de l'expérience de conception de code.


Patron Singleton (Singleton)

Garantir qu'une classe n'a qu'une seule instance et fournir un point d'accès global.

Exemple

// Patron Singleton : garantir une seule instance
class Singleton {
    // Stocker l'instance Singleton
    private static instance: Singleton;
    private static _data: string = "";

    // Constructeur privé pour empêcher l'instanciation externe
    private constructor() {}

    // Méthode statique pour obtenir l'instance Singleton
    public static getInstance(): Singleton {
        if (!Singleton.instance) {
            Singleton.instance = new Singleton();
        }
        return Singleton.instance;
    }

    // Définir les données
    public setData(data: string): void {
        Singleton._data = data;
    }

    // Obtenir les données
    public getData(): string {
        return Singleton._data;
    }
}

// Tester le patron singleton
const instance1 = Singleton.getInstance();
const instance2 = Singleton.getInstance();

// Vérifier qu'il s'agit de la même instance
console.log("Est la même instance : " + (instance1 === instance2));

instance1.setData("Hello Singleton");
console.log("Data: " + instance2.getData());

Sortie :

是同一实例: true
数据: Hello Singleton

Constructeur privé :En définissant le constructeur comme privé, cela empêche l'instanciation externe à l'aide de `new`.


Patron de fabrique (Factory)

Utiliser une fabrique générique pour créer des instances d'objets à typage sûr.

Exemple

// Définir l'interface produit
interface Product {
    name: string;
    price: number;
    getDescription(): string;
}

// Produit concret : électronique
class ElectronicProduct implements Product {
    constructor(
        public name: string,
        public price: number,
        public warranty: number
    ) {}

    getDescription(): string {
        return `${this.name} - ¥${this.price} (warranty${this.warranty}year)`;
    }
}

// Produit concret : vêtement
class ClothingProduct implements Product {
    constructor(
        public name: string,
        public price: number,
        public size: string
    ) {}

    getDescription(): string {
        return `${this.name} - ¥${this.price} (size: ${this.size})`;
    }
}

// Classe de fabrique
class ProductFactory {
    // Méthode de fabrique générique
    static create<T extends Product>(
        type: new (...args: any[]) => T,
        ...args: any[]
    ): T {
        return new type(...args);
    }
}

// Utiliser la fabrique pour créer des produits
const laptop = ProductFactory.create(ElectronicProduct, Laptop, 5999, 2);
const shirt = ProductFactory.create(ClothingProduct, T-shirt, 199, "L");

console.log(laptop.getDescription());
console.log(shirt.getDescription());

Fabrique générique :Utiliser des contraintes génériques pour garantir qu'un type de produit concret est renvoyé.


Patron de conception Decorator (Decorator)

Utiliser des décorateurs pour ajouter dynamiquement des fonctionnalités aux objets.

Exemple

// Interface de base pour le café
interface Coffee {
    getCost(): number;
    getDescription(): string;
}

// Implémentation de base du café
class SimpleCoffee implements Coffee {
    getCost(): number {
        return 10;
    }

    getDescription(): string {
        return Coffee;
    }
}

// Classe de base du décorateur
abstract class CoffeeDecorator implements Coffee {
    constructor(protected coffee: Coffee) {}

    getCost(): number {
        return this.coffee.getCost();
    }

    getDescription(): string {
        return this.coffee.getDescription();
    }
}

// Décorateur de lait
class MilkDecorator extends CoffeeDecorator {
    getCost(): number {
        return this.coffee.getCost() + 2;
    }

    getDescription(): string {
        return this.coffee.getDescription() + ", Lait";
    }
}

// Décorateur de sucre
class SugarDecorator extends CoffeeDecorator {
    getCost(): number {
        return this.coffee.getCost() + 1;
    }

    getDescription(): string {
        return this.coffee.getDescription() + ", Sugar";
    }
}

// Utiliser le décorateur
let coffee: Coffee = new SimpleCoffee();
console.log(coffee.getDescription() + " - ¥" + coffee.getCost());

coffee = new MilkDecorator(coffee);
console.log(coffee.getDescription() + " - ¥" + coffee.getCost());

coffee = new SugarDecorator(coffee);
console.log(coffee.getDescription() + " - ¥" + coffee.getCost());

Décorateur :Il peut ajouter dynamiquement de nouvelles fonctionnalités sans modifier la classe d'origine, et c'est une fonctionnalité expérimentale de TypeScript.


Patron Observer (Observer)

Définir une dépendance de un à plusieurs entre objets ; lorsque l'état d'un objet change, tous les dépendants sont notifiés.

Exemple

// Interface Observer
interface Observer {
    update(message: string): void;
}

// Interface Subject
interface Subject {
    attach(observer: Observer): void;
    detach(observer: Observer): void;
    notify(): void;
}

// Sujet concret : centre de messages
class MessageCenter implements Subject {
    private observers: Observer[] = [];
    private message: string = "";

    // Ajouter un observateur
    attach(observer: Observer): void {
        this.observers.push(observer);
    }

    // Supprimer un observateur
    detach(observer: Observer): void {
        const index = this.observers.indexOf(observer);
        if (index > -1) {
            this.observers.splice(index, 1);
        }
    }

    // Notifier tous les observateurs
    notify(): void {
        for (const observer of this.observers) {
            observer.update(this.message);
        }
    }

    // Publier un message
    publish(message: string): void {
        this.message = message;
        console.log("Publier le message: " + message);
        this.notify();
    }
}

// Observateur concret : utilisateur
class UserObserver implements Observer {
    constructor(public name: string) {}

    update(message: string): void {
        console.log(`[${this.name}]receivesMessage: ${message}`);
    }
}

// Utiliser le patron observateur
const center = new MessageCenter();

const user1 = new UserObserver("Utilisateur A");
const user2 = new UserObserver("Utilisateur B");

center.attach(user1);
center.attach(user2);

center.publish("La nouvelle fonctionnalité est en ligne !");

Découplage :Le patron Observateur met en œuvre un couplage faible entre les sujets et les observateurs.


Patron Stratégie (Stratégie)

Définir une série d’algorithmes, les encapsuler un par un et les rendre interchangeables.

Exemple

// Interface de stratégie de paiement
interface PaymentStrategy {
    pay(amount: number): void;
}

// Stratégie WeChat Pay
class WechatPayStrategy implements PaymentStrategy {
    pay(amount: number): void {
        console.log(`Utilisation de WeChat Pay ¥${amount}`);
    }
}

// Stratégie Alipay
class AlipayStrategy implements PaymentStrategy {
    pay(amount: number): void {
        console.log(`Utilisation d'Alipay ¥${amount}`);
    }
}

// Stratégie de carte bancaire
class CardPayStrategy implements PaymentStrategy {
    pay(amount: number): void {
        console.log(`Utilisation de la carte bancaire ¥${amount}`);
    }
}

// Contexte de paiement
class PaymentContext {
    private strategy: PaymentStrategy;

    constructor(strategy: PaymentStrategy) {
        this.strategy = strategy;
    }

    // Définir la stratégie de paiement
    setStrategy(strategy: PaymentStrategy): void {
        this.strategy = strategy;
    }

    // Exécuter le paiement
    pay(amount: number): void {
        this.strategy.pay(amount);
    }
}

// Utiliser le patron de stratégie
const context = new PaymentContext(new WechatPayStrategy());
context.pay(100);

context.setStrategy(new AlipayStrategy());
context.pay(200);

context.setStrategy(new CardPayStrategy());
context.pay(300);

Changement d'algorithme :Le patron de stratégie peut changer d'algorithme à l'exécution, offrant une grande flexibilité.


Injection de dépendances

Injecter les dépendances via le constructeur ; c'est l'un des patrons les plus couramment utilisés en TypeScript.

Exemple

// Définir l'interface de service
interface Logger {
    log(message: string): void;
}

interface Storage {
    save(key: string, data: any): void;
}

// Implémentation concrète du service
class ConsoleLogger implements Logger {
    log(message: string): void {
        console.log("[Journal]: " + message);
    }
}

class LocalStorage implements Storage {
    save(key: string, data: any): void {
        console.log(`Enregistrer ${key}: ${JSON.stringify(data)}`);
        localStorage.setItem(key, JSON.stringify(data));
    }
}

// Service utilisant l'injection de dépendances
class UserService {
    constructor(
        private logger: Logger,
        private storage: Storage
    ) {}

    createUser(name: string): void {
        const user = { name, createdAt: new Date() };
        this.logger.log("Créer un utilisateur : " + name);
        this.storage.save("user", user);
    }
}

// Injecter la dépendance
const logger = new ConsoleLogger();
const storage = new LocalStorage();
const userService = new UserService(logger, storage);

userService.createUser("Alice");

Inversion de dépendance :L'injection de dépendances garantit que les modules de haut niveau ne dépendent pas des modules de bas niveau, mais plutôt d'interfaces abstraites.


Patron de conception Builder (Builder)

Séparer la construction d'un objet complexe de sa représentation, afin que le même processus de construction puisse créer différentes représentations.

Exemple

// Interface du Builder
interface Builder<T> {
    build(): T;
}

// Objet complexe : configuration utilisateur
interface UserConfig {
    name: string;
    email: string;
    age?: number;
    role?: string;
    theme?: string;
}

// Générateur de configuration utilisateur
class UserConfigBuilder implements Builder<UserConfig> {
    private config: Partial<UserConfig> = {};

    setName(name: string): this {
        this.config.name = name;
        return this;
    }

    setEmail(email: string): this {
        this.config.email = email;
        return this;
    }

    setAge(age: number): this {
        this.config.age = age;
        return this;
    }

    setRole(role: string): this {
        this.config.role = role;
        return this;
    }

    setTheme(theme: string): this {
        this.config.theme = theme;
        return this;
    }

    build(): UserConfig {
        if (!this.config.name || !this.config.email) {
            throw new Error("Le nom et l'adresse e-mail sont requis");
        }
        return this.config as UserConfig;
    }
}

// Utiliser le builder
const builder = new UserConfigBuilder();
const config = builder
    .setName("Alice")
    .setEmail("alice@example.com")
    .setAge(25)
    .setRole("admin")
    .setTheme("dark")
    .build();

console.log("Configuration utilisateur :", JSON.stringify(config, null, 2));

Appels chaînés :Le patron de conception Builder prend en charge les appels chaînés, ce qui rend le code plus concis et lisible.


Notes

  • Sécurité des types :Utilisez le système de types de TypeScript pour garantir la sécurité des implémentations de patrons.
  • N'en faites pas trop :N'utilisez les patrons de conception que lorsqu'ils sont vraiment nécessaires.
  • Restez simple :Préférez les solutions simples.
  • Consensus d'équipe :Unifier l'utilisation des patrons de conception au sein de l'équipe.

Bonne pratique :Les patrons de conception sont des outils, pas des dogmes. Choisissez le patron qui correspond à la situation réelle du projet.


Résumé

Les patrons de conception sont une expérience importante dans l'organisation du code.

  • Patron Singleton :Garantir qu'une classe n'a qu'une seule instance
  • Patron Factory :Encapsuler le processus de création d'objets
  • Patron Decorator :Ajouter dynamiquement des fonctionnalités
  • Patron Observer :Relation de dépendance un-à-plusieurs
  • Patron Strategy :Les algorithmes sont remplaçables
  • Injection de dépendances :Découpler les dépendances

Suggestion :Comprendre et appliquer les patrons de conception en pratique peut vous aider à écrire un code plus élégant et plus facile à maintenir.

Autres extensions