Singleton Pattern in TypeScript

Welcome to the first lesson in our Creational Design Patterns course. We are starting with a powerful and widely used pattern: the Singleton Pattern. This pattern helps ensure that a class has only one instance and provides a global point of access to it. Understanding this pattern is a fantastic first step on your journey to mastering creational design patterns.

The Singleton Pattern is one of the simplest and most commonly used design patterns in software development. Its primary purpose is to restrict the instantiation of a class to a single object. This pattern ensures that a class has only one instance, simplifying the management of shared resources and offering a global access point to that instance.

Implementing the Singleton Pattern is particularly useful for scenarios such as managing configuration settings, handling logging, or controlling access to a shared database connection. By following this pattern, you avoid the redundant creation of multiple instances and maintain consistent behavior across your application.

Imagine you are building an application that needs to load configuration settings from a file. If each module within the application creates its own instance of the configuration loader, you could end up with unnecessary duplicates and inconsistencies. By using the Singleton Pattern, you ensure that all parts of the application use the same instance of the configuration loader, thereby maintaining a consistent and efficient approach to configuration management.

In TypeScript, you can use static methods and class properties to control instance creation, with the added benefit of type safety and explicit type annotations. For the Singleton Pattern, this logic will check whether an instance of the class already exists. If it does, the existing instance is returned. Otherwise, a new instance is created and stored.

Here's how this looks in the context of the Singleton Pattern in TypeScript:

class Singleton {
    private static instance: Singleton | null = null;

    private constructor() {
        // Private constructor prevents direct instantiation
    }

    public static getInstance(): Singleton {
        if (Singleton.instance === null) {
            Singleton.instance = new Singleton();
        }
        return Singleton.instance;
    }
}

In this example:

• The static class property instance is explicitly typed as Singleton | null and is used to store the single instance of the class.
• The constructor is marked as private to prevent direct instantiation from outside the class.
• The static method getInstance returns an instance of Singleton. It checks if instance is null. If it is, meaning no instance has been created yet, it creates a new instance of the Singleton class.
• The new instance is assigned to instance and returned.
• If instance is not null, meaning an instance already exists, the existing instance is returned.

By following this approach, you ensure that only one instance of the class is ever created. This is the cornerstone of implementing the Singleton Pattern in TypeScript.