{

Typescript Singleton pattern Implementation with example


In this blog post, learn the Singleton pattern in Typescript with examples.

Singleton Design pattern

Singleton is one of the simple and frequently used design patterns in application development.

It is a creational design pattern that enables the creation of a single instance or object of a class in the application. Only Once an instance of the class is created in an application.

Every programming language provides an implementation for this pattern.
We can also implement the singleton pattern in Typescript. This is a simple creation pattern.

Singleton Pattern implementation

  • Private modifier for the constructor, So that This class cannot be created by other classes.
  • A private Static variable that always returns the instance of the same class
  • A public static function that returns the instance of the class

Singleton pattern class example

Here are step by steps for singleton class

  • Created Instance static member variables, which can be accessed using class instead of Object instances.
  • And also added a private keyword added to a static member
  • added private modifier to Constructor.
  • Outside classes can not be created using the new operator.
  • Declared static method or a function, which checks if the instance is null or undefined, creates an instance, and returns it, if already exists, just returned the instance.

Here is a code for typescript singleton class example.

export default class SingletonClass {  
    private static instance?: SingletonClass;  
    private constructor() {  
    }  
    public static getInstance() {  
        if (!SingletonClass.instance) {  
            SingletonClass.instance = new SingletonClass();  
        }  
        return SingletonClass.instance;  
    }  
}  

We have created a singleton class, Now we are ready to test the singleton class.

Here is a code testing the above class

let instance1 = new SingletonClass() // This gives compilation error  
  
let instance2 = SingletonClass.getInstance()   
let instance3 = SingletonClass.getInstance()   
  
console.log(instance2==instance3) // true 

If you create an object using the new operator, it gives compilation error - constructor of class ‘SingletonClass’ is private only accessible within class declaration.

Conclusion

In this short tutorial, You learned about creating a singleton class and testing a singleton class for example.

Use cases and advantages

  • Providing global access for object creation of a class, It always has one instance maintained.
  • In applications, If you are implementing application caching, You will maintain only a single instance of a cache object always.
  • Maintain a single instance when you are dealing with the global configuration in the application.
THE BEST NEWSLETTER ANYWHERE
Join 6,000 subscribers and get a daily digest of full stack tutorials delivered to your inbox directly.No spam ever. Unsubscribe any time.

Similar Posts
Subscribe
You'll get a notification every time a post gets published here.