Science Knowings: JavaScript Course For Social Media

Singleton Pattern

Singleton Pattern

Previously, we discussed the Revealing Module Pattern, which is a powerful technique for creating modular and reusable code. Today, we're stepping into the world of Singleton Pattern, a design pattern that ensures there's only ever one instance of a class.

Definition - Singleton Pattern

The Singleton Pattern is a creational design pattern that restricts the instantiation of a class to only one object. This single instance is shared across the entire application, making it a global point of access.

Benefits of Singleton Pattern

Singletons offer several benefits:
- Centralized control over object creation
- Enforces a single point of access to data or resources
- Simplifies dependency management
- Reduces memory usage and potential conflicts

Code Example - Singleton Pattern

// Singleton Pattern Implementation

const Singleton = (function() {
  let instance;

  function createInstance() {
    if (!instance) {
      instance = new Object("I am the only instance");
    return instance;

  return {
    getInstance: createInstance

// Usage:
const instance1 = Singleton.getInstance();
const instance2 = Singleton.getInstance();
console.log(instance1 === instance2); // true

Real-World Applications - Singleton Pattern

Singleton Pattern finds practical applications in various scenarios:
- Database connections: Ensuring only one database connection is established
- Logging systems: Centralizing logging operations
- Configuration management: Providing a single source of truth for application settings

Global Namespace Pollution

Using global variables can lead to namespace pollution, where multiple scripts or modules can inadvertently modify the same global variable, causing conflicts and errors.

How to Avoid Global Namespace Pollution

To avoid global namespace pollution:
- Use local variables within functions and modules
- Declare variables with let or const instead of var
- Consider using a module system like CommonJS or AMD

Implementation Options

There are two main approaches to implementing Singleton Pattern:
- Lazy Initialization: Creates the instance only when it's first requested
- Eager Initialization: Creates the instance immediately when the class is loaded

Lazy Initialization

// Lazy Initialization

class Singleton {
  static instance;

  static getInstance() {
    if (!this.instance) {
      this.instance = new Singleton();
    return this.instance;

Eager Initialization

// Eager Initialization

class Singleton {
  static instance = new Singleton();

  static getInstance() {
    return this.instance;

Thread Safety

In multi-threaded environments, it's crucial to ensure thread safety when implementing Singleton Pattern. Techniques like synchronization can be employed to handle concurrent access.

Advantages & Disadvantages - Singleton Pattern

Centralized control over object creationLimited flexibility compared to other design patterns
Enforces a single point of accessCan lead to a tight coupling between classes
Simplifies dependency managementCan create a single point of failure
Reduces memory usageIncreased complexity for testing

Alternatives to Singleton Pattern

In certain cases, alternatives to Singleton Pattern may be more suitable:
- Factory Pattern: Creates objects without exposing the instantiation logic
- Dependency Injection: Provides objects to dependent classes without hard-coding them

Next: Factory Pattern

In our next session, we'll dive into the Factory Pattern, a creational design pattern that provides an interface for creating objects while hiding the implementation details. Follow us to stay updated!