The problem of singletons

Singletons are a design pattern in which a class is designed to have only one instance and provides a global point of access to that instance. In JavaScript, singletons can be implemented using a variety of techniques.

For example, the browser itself provides a number of singleton objects and functions that are available globally, such as the window object and the console object. These objects and functions provide access to various browser APIs and features, such as the DOM, the JavaScript runtime, and the browser console.

The use of singletons can be controversial in software development because they can make it difficult to reason about the state of an application and can create tight coupling between components. In addition, singletons can make it difficult to test and maintain code because they can introduce two major problems:

1. global state

Global state refers to state that is shared across multiple components or modules in an application and is not localized to a specific component or module. This can make it difficult to understand the behavior of the code because the state of the application can be affected by many different components, and it can be difficult to determine which components are responsible for specific changes to the state.

1. dependencies that are not explicit. it is not clear which components or modules depend on a singleton or how the singleton is used. This can make it difficult to understand the relationships between components and to modify the code without breaking existing functionality.

For example, consider the following code that defines a singleton class:

class Singleton {
  private static instance: Singleton;

  private constructor() {}

  static getInstance() {
    if (!Singleton.instance) {
      Singleton.instance = new Singleton();
    }
    return Singleton.instance;
  }
}

This singleton class is designed to have only one instance and provides a global point of access to that instance through the getInstance method. If this singleton class is used in multiple places in an application, it is not clear which components or modules depend on the singleton or how the singleton is being used. This can make it difficult to understand the relationships between components and to modify the code without breaking existing functionality.

For example, if you wanted to modify the behavior of the singleton, you might not know which components or modules are using the singleton and how they are using it. This can make it difficult to test and maintain the code, as you might have to modify or update many different components or modules that are using the singleton in order to make the desired changes.