Design Patterns Every Developer Should Know

When working on a small project, you can usually get away with writing code however feels natural at the time. As the project grows, though, things start to get complicated.

A class becomes responsible for too many things. A simple if statement turns into ten different conditions. Changing one feature suddenly breaks another part of the application.

This is where design patterns can help.

Design patterns are common approaches to solving problems that developers often run into when designing software. They are not libraries or frameworks, and you don't need to force them into every project. Instead, they give you a set of ideas that can make your code easier to organize and maintain.

What Exactly Is a Design Pattern?

A design pattern is basically a reusable solution to a common software design problem.

It doesn't mean copying a piece of code from somewhere and putting it into your project. A pattern describes the relationship between different parts of your application and how they should work together.

For example, imagine you have several ways to send notifications:

• Email
• SMS
• Push notifications

You could put everything into one huge function with a lot of if/else statements. It might work at first, but adding another notification method would make the function even harder to maintain.

A design pattern can give you a cleaner structure where each notification method has its own implementation.

The Three Main Categories

Design patterns are commonly divided into three categories: Creational, Structural, and Behavioral.

1. Creational Patterns

Creational patterns deal with how objects are created.

Some common examples are:

• Factory
• Abstract Factory
• Builder
• Singleton
• Prototype

The Factory Pattern, for example, can be useful when you need to create different objects depending on some condition.

Instead of spreading object creation throughout your application, you can put that logic in one place.

interface Notification {
  send(message: string): void;
}

class EmailNotification implements Notification {
  send(message: string) {
    console.log(`Sending email: ${message}`);
  }
}

class SMSNotification implements Notification {
  send(message: string) {
    console.log(`Sending SMS: ${message}`);
  }
}

function createNotification(type: string): Notification {
  if (type === "email") {
    return new EmailNotification();
  }

  return new SMSNotification();
}