Summer SALE

Singleton in TypeScript

Singleton is a creational design pattern, which ensures that only one object of its kind exists and provides a single point of access to it for any other code.

Singleton has almost the same pros and cons as global variables. Although they’re super-handy, they break the modularity of your code.

You can’t just use a class that depends on a Singleton in some other context, without carrying over the Singleton to the other context. Most of the time, this limitation comes up during the creation of unit tests.



Usage examples: A lot of developers consider the Singleton pattern an antipattern. That’s why its usage is on the decline in TypeScript code.

Identification: Singleton can be recognized by a static creation method, which returns the same cached object.

Conceptual Example

This example illustrates the structure of the Singleton design pattern and focuses on the following questions:

  • What classes does it consist of?
  • What roles do these classes play?
  • In what way the elements of the pattern are related?

index.ts: Conceptual example

 * The Singleton class defines an `instance` getter, that lets clients access
 * the unique singleton instance.
class Singleton {
    static #instance: Singleton;

     * The Singleton's constructor should always be private to prevent direct
     * construction calls with the `new` operator.
    private constructor() { }

     * The static getter that controls access to the singleton instance.
     * This implementation allows you to extend the Singleton class while
     * keeping just one instance of each subclass around.
    public static get instance(): Singleton {
        if (!Singleton.#instance) {
            Singleton.#instance = new Singleton();

        return Singleton.#instance;

     * Finally, any singleton can define some business logic, which can be
     * executed on its instance.
    public someBusinessLogic() {
        // ...

 * The client code.
function clientCode() {
    const s1 = Singleton.instance;
    const s2 = Singleton.instance;

    if (s1 === s2) {
            'Singleton works, both variables contain the same instance.'
    } else {
        console.log('Singleton failed, variables contain different instances.');


Output.txt: Execution result

Singleton works, both variables contain the same instance.

Singleton in Other Languages

Singleton in C# Singleton in C++ Singleton in Go Singleton in Java Singleton in PHP Singleton in Python Singleton in Ruby Singleton in Rust Singleton in Swift