The 5 Essential Design Patterns to Structure Robust and Testable Code

Design patterns are proven solutions to recurring software architecture problems. Formalized by the Gang of Four (GoF), they provide a common vocabulary and help avoid reinventing the wheel when faced with complex needs.

1. Strategy: Eliminate Nested Conditions

The Strategy pattern lets you define a family of algorithms, wrap them in separate classes, and swap them out at runtime.

Use case: Dynamic pricing engines, discount calculations, or payment gateways (Stripe, PayPal, Bank Transfer).

interface PaymentStrategy {
  pay(amount: number): Promise;
}

class StripePayment implements PaymentStrategy {
  async pay(amount: number): Promise<boolean> {
    // Logique API Stripe
    return true;
  }
}

class PayPalPayment implements PaymentStrategy {
  async pay(amount: number): Promise<boolean> {
    // Logique API PayPal
    return true;
  }
}

2. Factory Method: Delegating Instantiation

The factory separates the object creation logic. Instead of directly instantiating classes with the new keyword in business code, a factory returns the right instance depending on the context.

Benefit: Strict adherence to the Open/Closed principle (open for extension, closed for modification).

3. Adapter: Integrating Heterogeneous Systems

The Adapter pattern converts the interface of an external class into an interface expected by your business domain. It creates a buffer that shields your code from breaks in third-party APIs.

Use case: Connecting a new logging provider or an email sending service without having to rewrite all the application modules.

4. Observer (Pub/Sub): Decoupling Events

The Observer sets up a one-to-many relationship where any change in the state of a subject automatically notifies a list of registered observers.

Use cases: Sending push notifications, updating reactive interfaces, and asynchronous synchronization of data streams.

5. Decorator: Extending Features on the Fly

The Decorator lets you attach extra behavior to an object dynamically without changing its original structure or using static inheritance.

Use case: Adding a caching layer (Redis), performance metrics, or logging to an existing service.

Summary

The goal of Design Patterns isn't to apply as many as possible, but to pick the right tool for the real need to avoid accidental complexity.