How to Implement Design Patterns in TypeScript: Singleton

What is the Singleton Design Pattern?

The Singleton design pattern is a creational design pattern that restricts the instantiation of a class to a single object. It ensures that there is only one instance of the class and provides a global point of access to that instance.

The Singleton pattern is useful in situations where you want to control the creation and access of a particular object. It is commonly used in scenarios where you need to have a single instance of a class that can be accessed from multiple parts of your program, such as a database connection, thread pools, caching mechanisms, or logging systems.

The Singleton design pattern offers several advantages:

Single instance: The Singleton pattern ensures that there is only one instance of a class throughout the application. This can be useful when you need to coordinate access to a shared resource or maintain a single state across multiple components.

Global access: The Singleton provides a global point of access to the instance, allowing any part of the code to easily access the same object without the need to pass references around. This simplifies the communication between different parts of the codebase.

Resource management: Singletons are often used to manage resources that should have a single point of control. For example, a database connection, file system access, or a thread pool. By encapsulating the resource management within a Singleton, you can ensure proper initialization, efficient usage, and controlled disposal of resources.

Lazy initialization: The Singleton pattern can support lazy initialization, meaning the instance is created only when it is first requested. This can be beneficial for performance and memory usage, especially in scenarios where the instance might not be needed throughout the application’s lifecycle.

Thread safety: When implemented correctly, the Singleton pattern can provide thread safety. By using techniques like double-checked locking or initializing the instance in a thread-safe manner, you can ensure that the Singleton instance is created correctly even in a multi-threaded environment.

Easy to use and maintain: The Singleton pattern provides a straightforward way to access and manage a single instance. It avoids the need for complex instantiation logic or passing references between objects. This can improve code readability, maintainability, and ease of use.

Despite these advantages, it’s important to use the Singleton pattern judiciously and consider its potential drawbacks, such as introducing global state, making testing more challenging, and potentially creating tight coupling between components. Careful design and consideration of alternatives are necessary to ensure the benefits outweigh the drawbacks in a given scenario.

How to Implement Singleton?

Let’s say we have a Logger class that handles logging messages throughout the application. We want to ensure that there is only one instance of the Logger class that can be accessed from different parts of our codebase.

class Logger {
  private static instance: Logger;
  
  private constructor() {
    // Private constructor to prevent instantiation from outside the class
  }
  
  public static getInstance(): Logger {
    if (!Logger.instance) {
      Logger.instance = new Logger();
    }
    return Logger.instance;
  }
  
  public log(message: string): void {
    console.log(`[LOG]: ${message}`);
  }
}

export default Logger.getInstance();

In this example, the Logger class has a private constructor, preventing direct instantiation from outside the class. The getInstance() method provides a way to access the single instance of the Logger class. If the instance doesn't exist, it creates a new one; otherwise, it returns the existing instance.

By using the getInstance() method, we can ensure that all references to the Logger class point to the same instance.

Note that TypeScript supports the private constructor and static members, making it easy to implement the Singleton pattern.