Modèles de conception en TypeScript : exemples et application

Patrons de conception en TypeScript : guide pratique

Les patrons de conception (design patterns) sont des solutions éprouvées aux problèmes typiques du développement logiciel. En TypeScript, grâce au typage strict et aux capacités de la POO, de nombreux patrons sont implémentés de manière particulièrement élégante et sécurisée. Dans cet article, nous allons analyser quatre patrons clés avec des exemples de code réels qui vous aideront à écrire un code plus flexible et maintenable.

1. Singleton (Singleton)

Le patron Singleton garantit qu'une classe n'a qu'une seule instance et fournit un point d'accès global à celle-ci. En TypeScript, cela est particulièrement utile pour gérer la configuration de l'application ou les connexions à la base de données.

Implémentation avec un constructeur privé et une méthode statique :

class DatabaseConnection {  private static instance: DatabaseConnection;  private connection: string;

  private constructor() {    this.connection = 'PostgreSQL connected';  }

  public static getInstance(): DatabaseConnection {    if (!DatabaseConnection.instance) {      DatabaseConnection.instance = new DatabaseConnection();    }    return DatabaseConnection.instance;  }

  public query(sql: string): void {    console.log(`Executing query: ${sql} on ${this.connection}`);  }}

// Использованиеconst db1 = DatabaseConnection.getInstance();const db2 = DatabaseConnection.getInstance();console.log(db1 === db2); // true - один и тот же объектdb1.query('SELECT * FROM users');

Quand l'utiliser : pour les journaux (loggers), les caches, les pools de threads, les paramètres d'application. Évitez le Singleton pour les états qui peuvent changer dans un environnement multithread.

2. Factory Method (Méthode de fabrique)

La Factory Method définit une interface pour créer un objet, mais permet aux sous-classes de modifier le type d'objet créé. En TypeScript, cela se combine parfaitement avec les interfaces et les classes abstraites.

Exemple de création de différents types de notifications :

interface Notification {  send(message: string): void;}

class EmailNotification implements Notification {  public send(message: string): void {    console.log(`Email sent: ${message}`);  }}

class SMSNotification implements Notification {  public send(message: string): void {    console.log(`SMS sent: ${message}`);  }}

abstract class NotificationFactory {  public abstract createNotification(): Notification;

  public notifyUser(message: string): void {    const notification = this.createNotification();    notification.send(message);  }}

class EmailNotificationFactory extends NotificationFactory {  public createNotification(): Notification {    return new EmailNotification();  }}

class SMSNotificationFactory extends NotificationFactory {  public createNotification(): Notification {    return new SMSNotification();  }}

// Использованиеconst factory: NotificationFactory = new EmailNotificationFactory();factory.notifyUser('Your order has been shipped!');

Quand l'utiliser : lorsque l'on ne sait pas à l'avance quelle classe concrète sera nécessaire, ou lorsque la logique de création d'objet est complexe et doit être centralisée.

3. Observer (Observateur)

L'Observer définit une relation "un à plusieurs" entre les objets : lorsque l'état d'un objet change, tous les objets dépendants sont notifiés automatiquement. En TypeScript, cela est souvent implémenté via les génériques pour typer les événements.

Exemple d'un système d'abonnement aux actualités :

interface Observer<T> {  update(data: T): void;}

class NewsPublisher<T> {  private observers: Observer<T>[] = [];

  public subscribe(observer: Observer<T>): void {    this.observers.push(observer);  }

  public unsubscribe(observer: Observer<T>): void {    this.observers = this.observers.filter(obs => o