Singleton ou observable ? Un mauvais choix pourrait vous coûter votre promotion !

Les modèles de conception sont fondamentaux pour créer des logiciels bien structurés et faciles à entretenir. Parmi eux, Singleton et Observable sont souvent utilisés dans des scénarios qui nécessitent un contrôle d'état global et une communication entre différentes parties du système. Dans cet article, nous explorerons le fonctionnement de ces deux normes, quand les utiliser, leurs différences et fournirons des exemples pratiques sur la façon de les mettre en œuvre.

Qu’est-ce que Singleton ?

Le Singleton Pattern est un modèle de conception créationnel qui garantit qu'une classe n'a qu'une seule instance et fournit un point d'accès global à cette instance. Ce modèle est utile lorsque vous avez besoin d'un seul objet dans l'ensemble de l'application, tel que les paramètres globaux, la connexion à la base de données ou la gestion des journaux.

Comment fonctionne Singleton ?

La principale caractéristique de Singleton est qu'il restreint l'instance de classe à un seul objet, garantissant que toutes les requêtes d'instance renvoient le même objet. Pour y parvenir, le modèle utilise normalement une méthode statique qui crée l'instance uniquement lorsqu'elle est demandée pour la première fois, garantissant ainsi la création et l'utilisation uniques de l'objet dans tout le système.

Dans le diagramme ci-dessous, la séquence montre comment l'instance Singleton est créée et accessible, garantissant qu'elle est unique.

Le diagramme de séquence Singleton illustre le flux d'interaction entre le client et la classe Singleton. Le processus commence avec le client appelant la méthode statique getInstance() pour obtenir l'instance Singleton. Si l'instance n'a pas encore été créée, Singleton crée une nouvelle instance et la renvoie. Lorsque le client appelle à nouveau la méthode getInstance(), la même instance est renvoyée, garantissant qu'il n'y a qu'une seule instance de l'objet Singleton pendant toute l'exécution du programme.

Exemple d'utilisation - Singleton dans TypeScript

class Singleton {
    private static instance: Singleton;

    private constructor() { }

    // Método para acessar a instância única
    public static getInstance(): Singleton {
        if (!Singleton.instance) {
            Singleton.instance = new Singleton();
        }
        return Singleton.instance;
    }

    public showMessage(): string {
        return "Esta é a única instância!";
    }
}

// Uso do Singleton
const instance1 = Singleton.getInstance();
console.log(instance1.showMessage()); // "Esta é a única instância!"
const instance2 = Singleton.getInstance();
console.log(instance1 === instance2); // true

Quand utiliser Singleton ?

• Paramètres globaux : lorsque vous avez besoin d'une seule instance pour stocker les paramètres système, tels que les variables d'environnement.
• Gestion des connexions : par exemple, pour gérer les connexions à une base de données ou à un serveur API.
• Gestion des ressources : lorsqu'il est nécessaire de contrôler l'accès à une ressource unique, comme un enregistreur ou un cache.

Qu’est-ce qui est observable ?

Le Modèle observable est un modèle de conception comportemental qui définit une dépendance un-à-plusieurs entre les objets. En d’autres termes, lorsque l’état d’un objet (le « sujet ») change, tous ses dépendants (les « observateurs ») sont automatiquement avertis. Ce modèle est largement utilisé dans les systèmes où les événements et les changements d'état doivent être propagés entre différents composants, tels que des interfaces graphiques ou des systèmes de surveillance.

Comment fonctionne Observable ?

Le modèle Observable permet aux objets « d'observer » les changements dans l'état d'un objet et de réagir à ces changements. Le modèle est basé sur trois éléments principaux :

1. Sujet : l'objet qui maintient l'état et envoie des notifications aux observateurs.
2. Observateur : objets qui s'intéressent aux changements d'état du Sujet.
3. Abonnement : un mécanisme qui permet à Observer de s'abonner ou de se désinscrire des notifications du Sujet.

Le diagramme de séquence observable montre comment le modèle fonctionne avec plusieurs observateurs. Le sujet (ou objet observé) informe tous les observateurs enregistrés lorsqu'un changement d'état se produit. Chaque observateur réagit à la notification en prenant les mesures nécessaires en fonction des informations reçues. Le processus de notification est propagé de manière à ce que tous les observateurs soient mis à jour simultanément, les gardant synchronisés avec l'état du sujet. Ce modèle est utile lorsque plusieurs composants ou parties du système doivent être informés des changements dans l'état d'un objet.

Exemple d'utilisation - Observable dans TypeScript

class Singleton {
    private static instance: Singleton;

    private constructor() { }

    // Método para acessar a instância única
    public static getInstance(): Singleton {
        if (!Singleton.instance) {
            Singleton.instance = new Singleton();
        }
        return Singleton.instance;
    }

    public showMessage(): string {
        return "Esta é a única instância!";
    }
}

// Uso do Singleton
const instance1 = Singleton.getInstance();
console.log(instance1.showMessage()); // "Esta é a única instância!"
const instance2 = Singleton.getInstance();
console.log(instance1 === instance2); // true

Quand utiliser Observable ?

• Événements dans les interfaces graphiques : pour réagir aux clics de boutons, aux modifications de champs ou aux mises à jour d'écran.
• Notification des changements d'état : lorsque plusieurs composants doivent être informés des modifications apportées à un objet.
• Modélisation réactive des flux de données : dans les systèmes où il y a propagation de données ou d'événements entre plusieurs systèmes, comme dans les applications basées sur des événements.

Différences entre Singleton et Observable

Bien que les deux modèles servent à gérer les objets de manière contrôlée, leurs objectifs et leurs comportements sont très différents :

Fonctionnalité

Característica	Singleton	Observable
Objetivo	Garantir que uma classe tenha apenas uma instância.	Notificar múltiplos objetos sobre mudanças de estado.
Instância	Apenas uma instância é criada e compartilhada.	Vários objetos podem ser observadores de um único sujeito.
Uso principal	Gerenciamento de recursos exclusivos.	Notificação de eventos e mudanças de estado.
Exemplo de uso	Gerenciamento de logs ou configuração global.	Atualização de interfaces gráficas ou propagação de eventos.

Célibataire

Observables

ête>

Objectif

Assurez-vous qu'une classe n'a qu'une seule instance. Avertissez plusieurs objets des changements d'état. Instance Une seule instance est créée et partagée. Plusieurs objets peuvent être observateurs d'un même sujet. Utilisation principale Gestion exclusive des ressources. Notification des événements et des changements d'état. Exemple d'utilisation Gestion des journaux ou configuration globale. Mise à jour des interfaces graphiques ou propagation d'événements. Conclusion

Les modèles Singleton et Observable

sont fondamentaux dans plusieurs situations de développement logiciel.

Singleton est idéal lorsque nous devons garantir une seule instance d'une classe dans toute l'application, tandis que Observable est utile pour notifier et gérer les interactions entre plusieurs objets en fonction des changements d'état . Lorsque vous choisissez entre ces modèles, tenez compte des besoins de votre projet. Utilisez Singleton lorsque le caractère unique d'une instance est cruciale pour l'application, et utilisez Observable lorsque votre système doit réagir à des changements d'état ou d'événements.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!