Forem: Ketan Jakhar

Mastering Design Patterns in JavaScript: Part 9 — The Mediator Pattern

Ketan Jakhar — Wed, 04 Dec 2024 16:51:01 +0000

Mediator Pattern — a design approach that centralizes communication to make your code more maintainable and less tangled.

Continue reading on JavaScript in Plain English »

Mastering Design Patterns in JavaScript: Part 8 — The Chain of Responsibility Pattern

Ketan Jakhar — Thu, 21 Nov 2024 16:19:21 +0000

Implementing the Chain of Responsibility Pattern in JavaScript for Clean, Scalable Code — Enhance Request Handling Today

Continue reading on JavaScript in Plain English »

Mastering Design Patterns in JavaScript: Part 7 — The Command Pattern

Ketan Jakhar — Tue, 12 Nov 2024 01:32:08 +0000

Encapsulate actions as objects in JS with the Command Pattern, enabling undo/redo, task scheduling, and flexible, decoupled operations.

Continue reading on JavaScript in Plain English »

Mastering Design Patterns in JavaScript: Part 6 — The Adapter Pattern

Ketan Jakhar — Fri, 08 Nov 2024 11:27:21 +0000

Master the Adapter Pattern in JavaScript to seamlessly integrate incompatible interfaces. Learn through practical examples, best practices,

Continue reading on JavaScript in Plain English »

Mastering Design Patterns in JavaScript: Part 5 — The Decorator Pattern

Ketan Jakhar — Tue, 05 Nov 2024 08:53:25 +0000

Hey folks! 👋

Continue reading on JavaScript in Plain English »

Mastering Design Patterns in JavaScript: Part 4 — The Strategy Pattern

Ketan Jakhar — Mon, 28 Oct 2024 12:25:05 +0000

Master the Strategy Pattern to simplify code, boost flexibility, and replace complex conditionals with reusable, maintainable strategies.

Continue reading on JavaScript in Plain English »

Mastering Design Patterns in JavaScript: Part 3 — The Observer Pattern

Ketan Jakhar — Mon, 21 Oct 2024 11:06:10 +0000

Learn to implement the Observer Pattern in JavaScript, enhancing app scalability, modularity, and event handling for efficient…

Continue reading on JavaScript in Plain English »

Mastering Design Patterns in JavaScript: Part 2 — The Factory Pattern

Ketan Jakhar — Sat, 19 Oct 2024 11:59:25 +0000

Welcome back to our deep dive into design patterns in JavaScript! If you joined us for the first part, we explored the Singleton Pattern…

Continue reading on JavaScript in Plain English »

Mastering Design Patterns in JavaScript: Part 1 — The Singleton Pattern

Ketan Jakhar — Wed, 16 Oct 2024 12:28:33 +0000

Mastering Design Patterns in JavaScript: Part 1 — The Singleton Pattern

Generated using AI

Welcome to the first part of our comprehensive series on design patterns in JavaScript! Whether you’re a newbie or an experienced developer, understanding design patterns is a game-changer for writing clean, efficient, and maintainable code. In this part, we’ll delve deep into one of the simplest yet impactful patterns: the Singleton Pattern. 🎉

What Exactly is the Singleton Pattern? 🤔

Imagine you’re building an application and need a class that should only have one instance throughout the entire app. Perhaps it’s a configuration manager, a logging utility, or a connection to a database. You don’t want multiple copies running around confusing.

That’s where the Singleton Pattern comes into play. It’s a design approach that ensures a class has only one instance and provides a global point of access to it.

When I first heard about Singletons, I thought, “Will I ever need just one instance of a class?” Then I ran into a project where multiple instances of a configuration object led to inconsistent settings across the app. Implementing a Singleton solved that problem beautifully.

Why Use the Singleton Pattern❓

1. Controlled Access to a Single Instance

By ensuring only one instance exists, you prevent conflicting states and maintain data consistency across your application. This is crucial for resources like database connections, logging mechanisms, or configuration settings. 🗄️

2. Lazy Initialization

Singletons are often lazily initialized — they’re created only when needed. This can improve performance by delaying heavy computations or resource-intensive setups until necessary. 💤

3. Global Access Point

Having a global access point simplifies the code needed to access certain resources. You don’t need to pass around instances; you can simply import or require the Singleton wherever it’s needed. 🌐

Implementing the Singleton Pattern in JavaScript 💻

Let’s get our hands dirty with some code!

Using Closures

One way to create a Singleton in JavaScript is by using closures:

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

  function init() {
    // Private methods and variables
    let privateVariable = 'I am private';
    function privateMethod() {
      console.log('I am a private method');
    }

    return {
      // Public methods and variables
      publicMethod: function () {
        console.log('I am a public method');
      },
      publicVariable: 'I am public',
    };
  }

  return {
    getInstance: function () {
      if (!instance) {
        instance = init();
      }
      return instance;
    },
  };
})();

const instance1 = Singleton.getInstance();
const instance2 = Singleton.getInstance();

console.log(instance1 === instance2); // Outputs: true

In this example:

We use an Immediately Invoked Function Expression (IIFE) to create a private scope.
The instance variable holds our Singleton instance.
The getInstance method checks if an instance exists. If not, it creates one.

Using ES6 Classes🎩

With modern JavaScript, we can implement a Singleton using classes for a cleaner approach:

class Singleton {
  constructor() {
    if (Singleton.instance) {
      return Singleton.instance;
    }
    Singleton.instance = this;

    // Initialization code here
    this.data = 'Some data';
  }
}

const obj1 = new Singleton();
const obj2 = new Singleton();

console.log(obj1 === obj2); // Output: true

Here’s what’s happening:

We check if Singleton.instance exists in the constructor.
If it does, we return that existing instance.
Otherwise, we set Singleton.instance to this.

Implementing a Singleton in TypeScript

TypeScript allows us to enhance this pattern with type safety:

class Singleton {
  private static instance: Singleton;

  private constructor() {
    // Some code here
  }

  public static getInstance(): Singleton {
    if (!Singleton.instance) {
      Singleton.instance = new Singleton();
    }
    return Singleton.instance;
  }

}

const obj1 = Singleton.getInstance();
const obj2 = Singleton.getInstance();

console.log(obj1 === obj2); // Output: true

Key Points:

The constructor is marked as private, preventing direct instantiation.
We provide a static getInstance method to control the instantiation.
This ensures only one instance of the class can exist.

Pros and Cons ⚖️

Pros👍

Single Point of Access : Makes it easy to manage shared resources.
Consistency : All parts of your application use the same instance.
Lazy Instantiation : The instance is created only when needed.

Cons👎

Global State : Singletons introduce a global state into your application, which can make debugging tricky.
Testing Challenges : Mocking Singletons in tests can be more complex.
Tight Coupling : Components become dependent on the Singleton, reducing modularity.

When to Use Singletons ❓

Singletons are useful in scenarios where:

Resource Sharing : You have a resource-intensive object that shouldn’t be duplicated (like a database connection).
Global Configuration : Application settings that need to be accessed throughout the app.
Logging Services : Maintaining a consistent logging mechanism.

For example, in one of my projects, we used a Singleton for the configuration manager. This ensured that no matter where we accessed the config, we were always getting the same settings.

Best Practices 🌟

To get the most out of Singletons while avoiding pitfalls:

Use Them Sparingly : Overusing Singletons can lead to code that’s hard to maintain.
Keep It Simple : Don’t overload your Singleton with too much functionality.
Be Mindful of Testing : Consider how you’ll mock or stub Singletons in your tests.

Common Pitfalls to Avoid 🚫

Hidden Dependencies

Relying on Singletons can create hidden dependencies in your code, making it less transparent and harder to maintain.

Difficulty in Unit Testing

Since Singletons introduce a global state, they can make unit tests less reliable if not handled properly.

Concurrency Issues

In environments where multiple processes or threads are involved, ensuring the Singleton remains truly single can be challenging.

Alternatives to Singletons 🤔

While Singletons can be useful, sometimes other patterns might be a better fit.

Dependency Injection🧩

Instead of relying on global instances, you can pass dependencies explicitly where needed.

class UserService {
  constructor(logger) {
    this.logger = logger;
  }

  createUser(user) {
    // Create user logic
    this.logger.log('User created');
  }
}

const logger = new Logger();
const userService = new UserService(logger);

This approach makes your code more modular and easier to test.

Real-World Use Cases 🌍

Configuration Manager⚙️

Having a single configuration manager ensures that all parts of your application read from the same set of configurations.

class ConfigManager {
  constructor() {
    if (ConfigManager.instance) {
      return ConfigManager.instance;
    }
    this.settings = {};
    ConfigManager.instance = this;
  }

  get(key) {
    return this.settings[key];
  }

  set(key, value) {
    this.settings[key] = value;
  }
}

Logging Service📝

A singleton logging service ensures all logs are written in a consistent format and stored in the same place.

class Logger {
  constructor() {
    if (Logger.instance) {
      return Logger.instance;
    }
    Logger.instance = this;
  }

  log(message) {
    console.log(`[${new Date().toISOString()}] ${message}`);
  }
}

Conclusion 🎯

The Singleton Pattern is a simple yet powerful tool that, when used appropriately, can help you manage shared resources effectively. But with great power comes responsibility! Be mindful of the potential downsides, and consider whether a Singleton best fits your particular scenario.

Thanks for joining me on this deep dive into the Singleton Pattern. I hope you found it helpful! In the next part of this series, we’ll tackle the Factory Pattern. It’s a fantastic design pattern that helps with object creation, making your code more flexible and scalable.

Feel free to share your thoughts or questions in the comments below. Let’s keep the conversation going! 💬

References 📚

Peace out!✌️

The Ultimate Guide to TypeScript’s Utility Types

Ketan Jakhar — Mon, 14 Oct 2024 12:04:50 +0000

Unlock the full potential of TypeScript by mastering its comprehensive set of utility types.

Continue reading on Medium »

JavaScript Is Broken!

Ketan Jakhar — Fri, 11 Oct 2024 08:49:13 +0000

🚨 JavaScript is broken! It can be full of surprises, even for seasoned developers! 😅 Whether it’s strange type conversions, automatic semicolon insertion, or the infamous floating-point math issue, these quirks can turn debugging into a real headache. But don’t worry, I’ve got you covered!

I just published an article on Medium breaking down some of the most common JavaScript pitfalls and how you can avoid them to write cleaner, more reliable code. 💻✨Read the full article here: https://codexstoney.medium.com/javascript-is-broken-8841df6f6fc8?sk=12a9f6601c827148be64c736a3032a91 🔗

In the article, you'll learn: 1️⃣ Why you should always specify the radix with parseInt() 2️⃣ How automatic semicolon insertion can give unexpected results 🛑 3️⃣ Why 0.1 + 0.2 !== 0.3 (and how to handle it!) 4️⃣ And more!

Let’s keep the conversation going! Have any funny or frustrating JavaScript stories? Drop them in the comments! 💡👇

JavaScript #TypeScript #DevLife #Medium

Real-Time Data Processing with Node.js, TypeScript, and Apache Kafka

Ketan Jakhar — Tue, 08 Oct 2024 12:20:28 +0000

Imagine orchestrating a symphony where each instrument plays in perfect harmony, even though they’re scattered across the globe. Sounds…

Continue reading on Medium »