Accueil/Notions/Pattern Command

Pattern Command

Le pattern Command, en programmation, est une méthode qui permet de transformer une requêtes ou une opération simple en un objets. Ce concept est utile car il permet de séparer le code qui initie une opération de celui qui sait comment l'opération doit être effectuée. Autrement dit, cela permet de découpler le code qui envoie la commande de celui qui la réalise.

L'intérêt principal de ce modèle est qu'il facilite l'extension et la modification des commandes sans changer le code qui les appelle. On peut ainsi ajouter de nouvelles commandes ou modifier celles existantes de manière plus flexible et maintenable.

Voici comment on peut implémenter le pattern Command en TypeScript:

  1. Définir l'interface Command: Cette interface déclare une méthode pour exécuter la commande. Toutes les commandes concrètes implémenteront cette interface.
interface Command {
    execute(): void;
}
  1. Créer des commandes concrètes: Chaque commande concrète implémente l'interface Command et définit dans la méthode execute ce qui doit être fait.
class LightOnCommand implements Command {
    private light: Light;

    constructor(light: Light) {
        this.light = light;
    }

    public execute(): void {
        this.light.turnOn();
    }
}

class LightOffCommand implements Command {
    private light: Light;

    constructor(light: Light) {
        this.light = light;
    }

    public execute(): void {
        this.light.turnOff();
    }
}

Dans cet exemple, LightOnCommand et LightOffCommand sont des commandes qui opèrent sur un objet Light. Chaque commande a une méthode execute qui appelle soit turnOn soit turnOff sur cet objet.

  1. Le receveur (Receiver): C'est l'objet sur lequel la commande effectue une action. Il contient la logique de l'opération.
class Light {
    public turnOn(): void {
        console.log("La lumière est allumée");
    }

    public turnOff(): void {
        console.log("La lumière est éteinte");
    }
}
  1. L'invocateur (Invoker): Il est chargé de lancer les commandes. Il ne sait rien sur la manière dont la commande est réalisée, il connaît seulement l'interface Command.
class RemoteControl {
    private onCommand: Command;
    private offCommand: Command;

    constructor(onCommand: Command, offCommand: Command) {
        this.onCommand = onCommand;
        this.offCommand = offCommand;
    }

    public pressOnButton(): void {
        this.onCommand.execute();
    }

    public pressOffButton(): void {
        this.offCommand.execute();
    }
}
  1. Utilisation du modèle Command:
const lamp = new Light();
const turnOnLamp = new LightOnCommand(lamp);
const turnOffLamp = new LightOffCommand(lamp);

const remote = new RemoteControl(turnOnLamp, turnOffLamp);
remote.pressOnButton(); // Affiche "La lumière est allumée"
remote.pressOffButton(); // Affiche "La lumière est éteinte"

Ce modèle est très puissant pour gérer des séquences d'actions, des annulations ou des macro-commandes. Il est largement utilisé dans les interfaces graphiques où chaque action de l'utilisateur peut être représentée comme une commande.

Pour approfondir tes connaissances en design patterns et concepts avancés en programmation, voici une liste de notions intéressantes que tu pourrais explorer :

  1. Pattern Observer : Ce pattern est utilisé pour créer un système où un objet, appelé sujet, notifie automatiquement une liste d'objets observateurs de tout changement d'état.

  2. Pattern Singleton : Ce Design Patterns|design pattern garantit qu'une classe n'a qu'une seule instance et fournit un point d'accès global à cette instance.

  3. Pattern Factory : Il permet de créer des objets sans spécifier la classe exacte de l'objet qui sera créé.

  4. Pattern Decorator : Ce pattern permet d'ajouter dynamiquement des fonctionnalités à un objet sans modifier le code des classes existantes.

  5. Pattern Stratégie (Strategy) : Ce modèle permet de définir une famille d'algorithmes, de les encapsuler chacun dans une classe, et de les rendre interchangeables.

  6. Pattern Façade : Ce pattern fournit une interface unifiée à un ensemble d'interfaces dans un sous-système, facilitant ainsi l'utilisation de ce sous-système.

  7. Connaissance/Pattern Adapter |Pattern Adapter : Ce Design Patterns|design pattern permet à des interfaces incompatibles de travailler ensemble en convertissant l'interface d'une classe en une autre interface attendue par les clients.

  8. Pattern Proxy : Ce pattern est utilisé pour fournir un substitut ou un représentant d'un autre objet pour contrôler l'accès à ce dernier.

  9. Programmation réactive : Explorer ce concept peut te permettre de comprendre comment gérer des flux de données asynchrones et les événements dans tes applications.

  10. Principes SOLID : Il s'agit d'un ensemble de cinq principes de conception orientée objet qui visent à rendre les logiciels plus compréhensibles, flexibles et maintenables.

  11. Event Sourcing : Ce concept implique de stocker l'état d'une entité sous forme de séquence d'événements plutôt que de simplement enregistrer son état final.

  12. CQRS (Command Query Responsibility Segregation) : Séparer les commandes (qui modifient l'état) des requêtes (qui retournent l'état) pour permettre une architecture plus propre et des optimisations de performance.

  13. architecture microservices : Apprends comment concevoir des applications sous forme de petits services autonomes qui communiquent via des API.

  14. Concurrency Patterns : Étudie les différentes façons de gérer les problèmes de concurrence dans le code, surtout pertinent pour les applications haute performance.

  15. GraphQL : Une alternative à REST pour le développement d'API qui permet de demander exactement ce dont le client a besoin et rien de plus.

Ces sujets te donneront une bonne base pour créer des applications robustes, évolutives et maintenables.