Singleton Method Design Pattern in JavaScript (original) (raw)

Last Updated : 3 Jan, 2025

Singleton Method or Singleton Design Pattern is a part of the **Gang of Four design pattern and it is categorized under **creational design patterns. It is one of the most simple design patterns in terms of modeling but on the other hand, this is one of the most controversial patterns in terms of complexity of usage.

Singleton-Method-Design-Pattern-in-java

Important Topics for the Singleton Method Design Pattern in JavaScript

1. What is Singleton Method Design Pattern in JavaScript?

Singleton pattern is a design pattern which restricts a class to instantiate its multiple objects. It is nothing but a way of defining a class. Class is defined in such a way that only one instance of the class is created in the complete execution of a program or project.

2. When to use the Singleton Method Design Pattern in JavaScript?

Here are some situations in JavaScript where the Singleton pattern may be applicable:

3. Key Component of Singleton Method Design Pattern in JavaScript:

Key-Component-of-Singleton-Method-Design-Pattern-in-JavaScript

**3.1. Private Constructor:

The class should have a private constructor to prevent instantiation of the class from external classes.

JavaScript `

const Singleton = (function () { // Private variable to store the instance let instance;

`

**3.2. Private Static Instance:

function Singleton() { if (instance) { // If an instance already exists, return that instance return instance; }

// Initialization code
// ...

// Assign `this` to the `instance` variable
instance = this;

}

``

**3.3. Public Static Method to Access the Instance:

Singleton.prototype.getInstance = function () { return instance; };

`

**3.4. Lazy Initialization:

Singleton.getInstance = function () { if (!instance) { // Lazy initialization: create the instance only when needed instance = new LazySingleton(); } return instance; };

`

**3.5. Prevention of Cloning and Serialization:

function revive(key, value) { if (key === '' && value && value.__isSingleton) { return instance; } return value; }

`

4. Implementation of Singleton Method Design Pattern in JavaScript

**Problem Statement:

Implement a Singleton pattern in JavaScript, ensuring that only one instance of a class is created and providing a mechanism to access that instance. Additionally, prevent cloning and serialization of the Singleton instance.

Step wise explaination of above Problem Statement

Implementation-of-Singleton-Method-Design-Pattern

Overall Code for Above Problem Statement in JavaScript:

JavaScript `

const Singleton = (function () { let instance;

function Singleton() { if (instance) { throw new Error("Singleton instance already exists. Use getInstance method."); } // Initialization code this.data = Math.random(); // Example: Initialization with random data }

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

Singleton.prototype.clone = function () { throw new Error("Cloning of singleton instance is not allowed."); };

Singleton.prototype.customDeserialize = function () { throw new Error("Deserialization of singleton instance is not allowed."); };

// JSON.parse reviver function to prevent deserialization function revive(key, value) { if (key === '' && value && value.__isSingleton) { return instance; } return value; }

Singleton.prototype.toJSON = function () { return JSON.stringify({ __isSingleton: true, data: this.data }); };

return Singleton; })();

// Usage try { const singletonInstance1 = Singleton.getInstance(); console.log(singletonInstance1);

// Attempting to create another instance should throw an error const singletonInstance2 = new Singleton(); } catch (error) { console.error(error.message); // Singleton instance already exists. Use getInstance method. }

// Cloning prevention try { const clonedInstance = Object.create(singletonInstance1); console.log(clonedInstance); // Will throw an error } catch (error) { console.error(error.message); // Cloning of singleton instance is not allowed. }

// Serialization prevention try { const serializedInstance = JSON.stringify(singletonInstance1); console.log(serializedInstance); // Will throw an error } catch (error) { console.error(error.message); // Serialization of singleton instance is not allowed. }

// Deserialization prevention const jsonString = JSON.stringify(singletonInstance1); const deserializedInstance = JSON.parse(jsonString, revive); console.log(deserializedInstance); // Will be the same instance as singletonInstance1

`

**Output:

Singleton instance already exists.
singletonInstance1 is not defined
singletonInstance1 is not defined

5. Use Case of Singleton Method Design Pattern in JavaScript

There is a application of singleton pattern like cache-memory, database connection, drivers, logging. Some major of them are :-

6. Advantages of Singleton Method Design Pattern in JavaScript:

The Singleton method design pattern has several benefits:

7. Disadvantages Of Singleton Method Design Pattern in JavaScript

The Singleton Method Design Pattern have different disadvantage: