This lesson follows Prototype. Prototype returns a copy. Singleton returns the same cached instance.

Singleton restricts a class to one instance within a defined runtime scope and provides a global access point. These are two responsibilities. The convenience also hides a dependency and makes mutable state shared.

Control creation and reuse one reference

A process has one registry of enabled features. Several services need that registry. An unrestricted constructor could create several conflicting registries. A private constructor and static accessor funnel callers through one cached reference.

class FeatureRegistry {
  private static instance: FeatureRegistry | undefined;
  private flags = new Map<string, boolean>();
  private constructor() {}

  static getInstance(): FeatureRegistry {
    if (!this.instance) this.instance = new FeatureRegistry();
    return this.instance;
  }
  enabled(name: string): boolean {
    return this.flags.get(name) ?? false;
  }
  set(name: string, enabled: boolean): void {
    this.flags.set(name, enabled);
  }
}

const a = FeatureRegistry.getInstance();
const b = FeatureRegistry.getInstance();
a === b; // true
a.set("newCheckout", true);
b.enabled("newCheckout"); // true

The first call initializes the instance. Later calls reuse it. The synchronous accessor above has no await between the check and assignment. This example assumes one JavaScript module instance in one execution context. TypeScript private is a compile-time restriction.

Protect initialization when execution can overlap

In a multithreaded runtime, two threads can both observe an empty cache and create separate instances. Use the language's initialization guarantees or a correctly synchronized accessor. Do not paste a double-checked lock without understanding the runtime's memory model.

Make the dependency visible when possible

A service that calls FeatureRegistry.getInstance() has a dependency its constructor does not reveal. Replacing the registry for an isolated environment becomes harder. A caller can still create one shared registry at application startup and pass it to every service.

interface Flags { enabled(name: string): boolean }
class Checkout {
  constructor(private flags: Flags) {}
  useNewFlow() { return this.flags.enabled("newCheckout"); }
}

const shared = FeatureRegistry.getInstance();
const checkout = new Checkout(shared);
const preview = new Checkout({ enabled: () => false });

Checkout depends on Flags. It does not require global access. Sharing one instance by application configuration is often enough. Requiring the class itself to enforce uniqueness is a stronger decision.

Map the roles

The pattern has only two roles. Most of its design work is in scope, initialization, and testing.

Role	In this example	Job
Singleton	FeatureRegistry	Hides its constructor and exposes a static getInstance() that always returns the same cached object
Client	any service that calls getInstance()	Reaches the instance only through the accessor, never through new

Reach for it when exactly one instance must serve every client

• a class must have exactly one instance available to all clients in a scope, such as one database connection pool shared by the whole process
• you need stricter control than a global variable gives. Any code can overwrite a global. Only the singleton class can replace its cached instance.
• you may later need a different limit. All creation goes through getInstance(), so changing that one method can allow a small fixed number of instances instead.

Implement it in five steps

Refactor existing code toward the pattern in this order:

1. Add a private static field that holds the instance.
2. Declare a public static creation method, getInstance(), that returns it.
3. Implement lazy initialization inside it: create the object on the first call, store it in the static field, and return the stored object on every later call.
4. Make the constructor private. The static method can still call it. Other code cannot.
5. Replace every direct constructor call in client code with a call to getInstance().

Name what it costs

You gain	You pay
One instance in the stated scope	Breaks single responsibility: it controls its own count and does its real job
A global access point to that instance	Can mask bad design, where components know too much about each other
Initialized only on first request	Multithreaded or async initialization needs special care so two callers do not create two objects
A clear owner for a shared resource	Hard to unit test: test frameworks often mock through subclasses, but the constructor is private and static methods cannot be overridden

Do not confuse it with its neighbors

Pattern	How it relates
Facade	One facade object is usually enough, so a facade is often made a singleton.
Flyweight	If all shared state fit in one flyweight, it would resemble a singleton. Two differences remain: a flyweight class can have many instances with different intrinsic state, and flyweights are immutable while a singleton can be mutable.
Abstract Factory, Builder, Prototype	Each can be implemented as a singleton when one instance is enough.

Retrieve and apply

Name a shared dependency in an application. State its required lifetime, who owns cleanup, and whether global access is necessary. Continue to Adapter when an existing object exposes the wrong interface.