Essential top 5 design patterns that will make your code suck less

Here's a quick summary and 5 common design patterns in software development that will make your code suck less and reduce the number of pesky bugs.

1. Singleton: Ensures that a class has only one instance and provides a global point of access to it.
2. Factory: Creates objects without specifying the exact class to create.
3. Builder: Separates the construction of a complex object from its representation, allowing for different representations.
4. Prototype: Creates objects by cloning an existing object rather than creating new objects from scratch.
5. Adapter: Allows incompatible classes to work together by converting the interface of one class into another.

These design patterns can help developers to create more modular, reusable, and maintainable code. For the actual explanation with pros, cons, and samples, continue reading below.

1. Singleton

A Singleton is a design pattern that ensures that a class has only one instance, and provides a global point of access to it. The idea is to create a class with a method that creates a new instance of the class if one doesn't already exist, and returns the existing instance if one does. This allows for only a single instance of the class to exist within the application, which can be useful for managing resources or for providing a global point of access to an object.

Pros of singleton pattern:

• Ensures that only one instance of a class is created, which can be useful for managing resources or providing a global point of access to an object.
• Can improve performance by avoiding the overhead of creating multiple instances of a class.

Cons of singleton pattern:

• Can introduce unnecessary complexity and make the code more difficult to understand and maintain.
• Can make it more difficult to test the code, since the Singleton can be difficult to mock or stub.

When to use singleton pattern:

• When you need to ensure that only one instance of a class is created.
• When you want to provide a global point of access to an object.
• When you want to improve performance by avoiding the overhead of creating multiple instances of a class.

Here is an example of a Singleton in JavaScript:

class Singleton {
  // The static instance variable holds the single instance of the class
  static instance = null;

  // The constructor is private to prevent direct construction of the object
  private constructor() {}

  // The getInstance method is used to retrieve the single instance of the class
  static getInstance() {
    if (Singleton.instance == null) {
      Singleton.instance = new Singleton();
    }
    return Singleton.instance;
  }
}

To use the Singleton, you would call the getInstance method, which will either create a new instance of the class or return the existing instance:

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

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

In this example, instance1 and instance2 will be the same object, because the getInstance method always returns the same instance of the Singleton class.

2. Factory

The Factory design pattern is a creational pattern that provides a way to create objects without specifying the exact class to create. The Factory pattern defines an interface for creating objects, but lets subclasses decide which class to instantiate. This allows for a level of abstraction between the creation of objects and the implementation of those objects.

Pros of factory pattern:

• Allows for the creation of objects without specifying the exact class to create.
• Provides a level of abstraction between the creation of objects and the implementation of those objects.
• Makes it easier to add new types of objects without modifying existing code.

Cons of factory pattern:

• Can add unnecessary complexity to the code, making it more difficult to understand and maintain.
• Can make it more difficult to see the relationship between the objects being created and the factory itself.