Understanding Design Patterns

What are Design Patterns?

Design patterns are proven solutions to common problems in software design. They are like blueprints that can be reused in various situations to simplify development and improve the quality of software.

In short: "Design patterns are templates for solving design challenges."

Why are Design Patterns Important?

1. Reusability: They save time by providing tested and proven development paradigms.
2. Improved Communication: Developers can communicate ideas more effectively using common terminology.
3. Scalability: They help build software that is easier to maintain and scale.
4. Consistency: Patterns bring consistency to the codebase, making it easier for teams to collaborate.

Types of Design Patterns

Design patterns are broadly categorized into three types:

1. Creational Patterns

These deal with object creation mechanisms, ensuring objects are created in a way that suits the situation.

Examples:

• Singleton: Ensures a class has only one instance and provides a global access point to it.

  class Singleton {
      constructor() {
          if (!Singleton.instance) {
              Singleton.instance = this;
          }
          return Singleton.instance;
      }
  }
   
  const instance1 = new Singleton();
  const instance2 = new Singleton();
  console.log(instance1 === instance2); // true

• Factory: Creates objects without specifying the exact class of object that will be created.

  class ShapeFactory {
      static createShape(type) {
          switch (type) {
              case 'circle':
                  return new Circle();
              case 'square':
                  return new Square();
          }
      }
  }
  const circle = ShapeFactory.createShape('circle');

2. Structural Patterns

These focus on the composition of classes and objects.

Examples:

• Adapter: Allows incompatible interfaces to work together.

  class OldSystem {
      getData() {
          return 'Old System Data';
      }
  }
  class Adapter {
      constructor(oldSystem) {
          this.oldSystem = oldSystem;
      }
      fetchData() {
          return this.oldSystem.getData();
      }
  }
  const adapter = new Adapter(new OldSystem());
  console.log(adapter.fetchData());

• Decorator: Adds new functionality to an object dynamically.

  class Coffee {
      cost() {
          return 5;
      }
  }
  class MilkDecorator {
      constructor(coffee) {
          this.coffee = coffee;
      }
      cost() {
          return this.coffee.cost() + 2;
      }
  }
  const coffeeWithMilk = new MilkDecorator(new Coffee());
  console.log(coffeeWithMilk.cost()); // 7

3. Behavioral Patterns

These deal with communication between objects.

Examples:

• Observer: Defines a dependency between objects so that when one object changes state, all its dependents are notified.

  class Subject {
      constructor() {
          this.observers = [];
      }
      addObserver(observer) {
          this.observers.push(observer);
      }
      notifyObservers(message) {
          this.observers.forEach(observer => observer.update(message));
      }
  }
  class Observer {
      update(message) {
          console.log('Observer received:', message);
      }
  }
  const subject = new Subject();
  const observer = new Observer();
  subject.addObserver(observer);
  subject.notifyObservers('Hello!');

• Strategy: Allows a class's behavior to be selected at runtime.

  class PaymentStrategy {
      pay(amount) {
          console.log('Paying', amount);
      }
  }
  class CreditCardPayment extends PaymentStrategy {
      pay(amount) {
          console.log('Paid', amount, 'with Credit Card');
      }
  }
  class PayPalPayment extends PaymentStrategy {
      pay(amount) {
          console.log('Paid', amount, 'with PayPal');
      }
  }
  const payment = new PayPalPayment();
  payment.pay(100);

Common Mistakes When Using Design Patterns

1. Overusing Patterns: Adding unnecessary complexity by using patterns where they aren't needed.
2. Misunderstanding Patterns: Misapplying a pattern without understanding its purpose.
3. Ignoring Simplicity: Remember, patterns should simplify, not complicate.

Conclusion

Design patterns are essential tools in a developer's toolkit. They help solve common problems in a structured way, making your code more maintainable, scalable, and readable.