Singleton pattern is the most simple design pattern out there to understand.

It restricts the instantiation of a class to a single instance and provides a global point of access to that instance throughout the application.

Lets straight away jump into the code to understand it better.

class Singleton {
    constructor() {
        if (Singleton.instance) {
            return Singleton.instance;
        }
        Singleton.instance = this;
    }
}

const instance = new Singleton();
Object.freeze(instance);

A very simple JavaScript class is created which checks if an instance of the class already exists.

If it does, it returns that instance instead of creating a new one. This way, we ensure that only one instance of the class is created throughout the application.

Once an instance is created using new Singleton(), we can freeze it using Object.freeze() to prevent any modifications to the instance.

Now this object is ready to be used across the application without worrying about multiple instances being created.

Any number of attributes and methods can be added to the class as per the requirements of the application.

Advantages of Singleton Pattern

The singleton pattern has several advantages -

1. Controlled Access: It provides a controlled access to the single instance, ensuring that only one instance of the class is created and used throughout the application.
2. Global State: It allows for a global state that can be accessed from anywhere in the application, making it easier to manage shared resources or configurations.
3. Lazy Initialization: The singleton instance can be created lazily, meaning it is only created when it is first needed, which can help improve performance and reduce memory usage in some cases.
4. Ease of Use: It is easy to implement and use, as it provides a simple way to ensure that only one instance of a class is created and accessed globally without the need for complex dependency management or object creation logic.

Drawbacks of Singleton Pattern

When dealing with a singleton, we need to be careful about the following drawbacks -

1. Global State: Singletons can lead to a global state which can be difficult to manage and debug, especially in larger applications.
2. Testing: Singletons can make unit testing difficult as they can introduce hidden dependencies and make it hard to isolate tests.
3. Concurrency Issues: In a multi-threaded environment, singletons can lead to concurrency issues if not implemented correctly, as multiple threads may try to create an instance at the same time, or invoke a method simultaneously.
4. Tight Coupling: Singletons can lead to tight coupling between classes, as they rely on a single instance, making it difficult to change the implementation or replace it with a different one in the future.

Video Source