Design patterns are fundamental in creating well-structured and easy-to-maintain software. Among them, Singleton and Observable are often used in scenarios that require global state control and communication between different parts of the system. In this article, we will explore how these two standards work, when to use them, their differences, and provide practical examples of how to implement them.

What is Singleton?

The Singleton Pattern is a creational design pattern that ensures that a class has only one instance and provides a global point of access to that instance. This pattern is useful when you need a single object across the entire application, such as global settings, database connection, or log management.

How does Singleton work?

The main feature of Singleton is that it restricts the class instance to a single object, ensuring that all instance requests return the same object. To achieve this, the pattern normally uses a static method that creates the instance only when it is requested for the first time, guaranteeing the unique creation and use of the object throughout the system.

In the diagram below, the sequence shows how the Singleton instance is created and accessed, ensuring it is unique.

The Singleton sequence diagram illustrates the interaction flow between the client and the Singleton class. The process begins with the client calling the static getInstance() method to obtain the Singleton instance. If the instance has not yet been created, Singleton creates a new instance and returns it. When the client calls the getInstance() method again, the same instance is returned, ensuring that there is only one instance of the Singleton object during the entire program execution.

Usage Example - Singleton in TypeScript

class Singleton {
    private static instance: Singleton;

    private constructor() { }

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

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

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

When to Use Singleton?

• Global Settings: When you need a single instance to store system settings, such as environment variables.
• Connection management: for example, to manage connections to a database or an API server.
• Resource management: when it is necessary to control access to a unique resource, such as a logger or cache.

What is Observable?

The Observable Pattern is a behavioral design pattern that defines a one-to-many dependency between objects. In other words, when the state of an object (the "subject") changes, all its dependents (the "observers") are automatically notified. This pattern is widely used in systems where events and state changes need to be propagated between different components, such as graphical interfaces or monitoring systems.

How does Observable work?

The Observable pattern allows objects to "observe" changes in the state of an object and react to those changes. The pattern is based on three main components:

1. Subject: the object that maintains state and sends notifications to observers.
2. Observer: objects that are interested in the State changes of the Subject.
3. Subscription: a mechanism that allows Observer to subscribe or unsubscribe to Subject notifications.

The Observable sequence diagram demonstrates how the pattern works with multiple observers. The Subject (or observed object) notifies all registered Observers when a state change occurs. Each Observer reacts to the notification, taking necessary actions based on the information received. The notification process is propagated so that all observers are updated simultaneously, keeping them synchronized with the state of the Subject. This pattern is useful when there are multiple components or parts of the system that need to be informed about changes in the state of an object.

Usage Example - Observable in TypeScript

class Singleton {
    private static instance: Singleton;

    private constructor() { }

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

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

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

When to Use Observable?

• Events in graphical interfaces: to react to button clicks, field changes, or screen updates.
• Notification of state changes: when several components need to be informed about changes to an object.
• Reactive data flow modeling: in systems where there is propagation of data or events between multiple systems, such as in event-based applications.

Differences between Singleton and Observable

Although both patterns serve to manage objects in a controlled way, their purposes and behaviors are very different:

Singleton is ideal when we need to guarantee a single instance of a class throughout the application, while Observable is useful for notifying and managing interactions between multiple objects based on state changes. When choosing between these patterns, consider the needs of your project. Use Singleton when the uniqueness of an instance is crucial to the application, and use Observable when your system needs to react to changes in state or events.

The above is the detailed content of Singleton or Observable? Wrong Choice Could Cost You Your Promotion!. For more information, please follow other related articles on the PHP Chinese website!