Design patterns are proven solutions to common problems in software design. Understanding these patterns is crucial for writing maintainable, scalable, and robust code. Let's dive deep into the 10 most important design patterns that every software engineer should know.
Introduction to Design Patterns
Before we explore specific patterns, it's important to understand what design patterns are and why they matter. Design patterns are reusable solutions to common problems in software design. They provide a template for solving issues that can occur repeatedly in software development, helping you write more maintainable and flexible code.
Speaking of maintainable code, if you're looking to showcase your understanding of design patterns in your portfolio, check out our professionally designed templates:
Now, let's dive into the essential design patterns.
1. Singleton Pattern
The Singleton pattern ensures a class has only one instance while providing global access to this instance.
When to Use:
- Managing shared resources
- Coordinating system-wide actions
- Managing configuration settings
Implementation Example:
class DatabaseConnection {
private static instance: DatabaseConnection;
private constructor() { }
public static getInstance(): DatabaseConnection {
if (!DatabaseConnection.instance) {
DatabaseConnection.instance = new DatabaseConnection();
}
return DatabaseConnection.instance;
}
public query(sql: string): void {
// Database query implementation
}
}
Considerations:
- Can make unit testing difficult
- May hide dependencies
- Thread safety concerns in concurrent environments
2. Factory Method Pattern
The Factory Method pattern provides an interface for creating objects but allows subclasses to alter the type of objects that will be created.
When to Use:
- When object creation logic should be encapsulated
- When working with multiple related products
- When you want to provide users with a way to extend your library's internal components
Implementation Example:
interface Animal {
speak(): void;
}
class Dog implements Animal {
speak() {
console.log('Woof!');
}
}
class Cat implements Animal {
speak() {
console.log('Meow!');
}
}
abstract class AnimalFactory {
abstract createAnimal(): Animal;
}
class DogFactory extends AnimalFactory {
createAnimal(): Animal {
return new Dog();
}
}
3. Observer Pattern
The Observer pattern defines a one-to-many dependency between objects where when one object changes state, all its dependents are notified and updated automatically.
When to Use:
- Event handling systems
- Real-time data synchronization
- UI updates based on data changes
Implementation Example:
interface Observer {
update(data: any): void;
}
class Subject {
private observers: Observer[] = [];
public subscribe(observer: Observer): void {
this.observers.push(observer);
}
public unsubscribe(observer: Observer): void {
const index = this.observers.indexOf(observer);
this.observers.splice(index, 1);
}
public notify(data: any): void {
this.observers.forEach(observer => observer.update(data));
}
}
4. Strategy Pattern
The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable.
When to Use:
- When you need different variants of an algorithm
- When you have conditional statements switching between different algorithms
- When algorithms need to be easily interchangeable
Implementation Example:
interface PaymentStrategy {
pay(amount: number): void;
}
class CreditCardPayment implements PaymentStrategy {
pay(amount: number): void {
console.log(`Paid ${amount} using Credit Card`);
}
}
class PayPalPayment implements PaymentStrategy {
pay(amount: number): void {
console.log(`Paid ${amount} using PayPal`);
}
}
class PaymentContext {
private strategy: PaymentStrategy;
constructor(strategy: PaymentStrategy) {
this.strategy = strategy;
}
executePayment(amount: number): void {
this.strategy.pay(amount);
}
}
5. Decorator Pattern
The Decorator pattern allows behavior to be added to individual objects dynamically without affecting other objects of the same class.
When to Use:
- Adding responsibilities to objects dynamically
- When extension by subclassing is impractical
- When you need to modify object behavior at runtime
Implementation Example:
interface Coffee {
cost(): number;
description(): string;
}
class SimpleCoffee implements Coffee {
cost(): number {
return 10;
}
description(): string {
return "Simple coffee";
}
}
class MilkDecorator implements Coffee {
constructor(private coffee: Coffee) {}
cost(): number {
return this.coffee.cost() + 2;
}
description(): string {
return this.coffee.description() + ", milk";
}
}
6. Command Pattern
The Command pattern encapsulates a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.
When to Use:
- When you need to parameterize objects with operations
- When you need to queue, specify, or execute requests at different times
- When you need to support undo operations
Implementation Example:
interface Command {
execute(): void;
undo(): void;
}
class Light {
turnOn(): void {
console.log("Light is on");
}
turnOff(): void {
console.log("Light is off");
}
}
class LightOnCommand implements Command {
constructor(private light: Light) {}
execute(): void {
this.light.turnOn();
}
undo(): void {
this.light.turnOff();
}
}
7. Proxy Pattern
The Proxy pattern provides a surrogate or placeholder for another object to control access to it.
When to Use:
- Lazy initialization
- Access control
- Logging
- Virtual proxy (loading expensive objects on demand)
Implementation Example:
interface Image {
display(): void;
}
class RealImage implements Image {
constructor(private filename: string) {
this.loadFromDisk();
}
private loadFromDisk(): void {
console.log(`Loading ${this.filename}`);
}
display(): void {
console.log(`Displaying ${this.filename}`);
}
}
class ProxyImage implements Image {
private realImage: RealImage | null = null;
constructor(private filename: string) {}
display(): void {
if (this.realImage === null) {
this.realImage = new RealImage(this.filename);
}
this.realImage.display();
}
}
8. Builder Pattern
The Builder pattern separates the construction of a complex object from its representation.
When to Use:
- When you need to create complex objects step by step
- When you want to create different representations of the same object
- When you need fine control over the construction process
Implementation Example:
class Computer {
constructor(
public cpu: string,
public ram: string,
public storage: string
) {}
}
class ComputerBuilder {
private cpu: string = "";
private ram: string = "";
private storage: string = "";
setCPU(cpu: string): ComputerBuilder {
this.cpu = cpu;
return this;
}
setRAM(ram: string): ComputerBuilder {
this.ram = ram;
return this;
}
setStorage(storage: string): ComputerBuilder {
this.storage = storage;
return this;
}
build(): Computer {
return new Computer(this.cpu, this.ram, this.storage);
}
}
9. State Pattern
The State pattern allows an object to alter its behavior when its internal state changes.
When to Use:
- When an object's behavior depends on its state
- When you have conditional statements that depend on an object's state
- When you need to manage state transitions explicitly
Implementation Example:
interface State {
handle(): void;
}
class ConcreteStateA implements State {
handle(): void {
console.log("Handling state A");
}
}
class ConcreteStateB implements State {
handle(): void {
console.log("Handling state B");
}
}
class Context {
private state: State;
constructor(state: State) {
this.state = state;
}
setState(state: State): void {
this.state = state;
}
request(): void {
this.state.handle();
}
}
10. Facade Pattern
The Facade pattern provides a unified interface to a set of interfaces in a subsystem.
When to Use:
- When you need to provide a simple interface to a complex subsystem
- When you want to layer your subsystems
- When you need to decouple your subsystem from clients
Implementation Example:
class CPU {
freeze(): void { console.log("CPU freeze"); }
jump(position: number): void { console.log(`CPU jump to ${position}`); }
execute(): void { console.log("CPU execute"); }
}
class Memory {
load(position: number, data: string): void {
console.log(`Memory load ${data} at ${position}`);
}
}
class ComputerFacade {
private cpu: CPU;
private memory: Memory;
constructor() {
this.cpu = new CPU();
this.memory = new Memory();
}
start(): void {
this.cpu.freeze();
this.memory.load(0, "boot data");
this.cpu.jump(0);
this.cpu.execute();
}
}
Implementing Design Patterns in Your Projects
When implementing these patterns in your projects, remember:
- Choose Wisely: Don't force patterns where they don't fit
- Keep It Simple: Use patterns to reduce complexity, not add to it
- Document Usage: Make sure to document why you chose a particular pattern
- Consider Maintenance: Think about how the pattern will affect long-term maintenance
- Test Thoroughly: Patterns can introduce new complexity that needs testing
If you're working on your portfolio and want to showcase your understanding of design patterns, our templates provide a perfect foundation:
Conclusion
Understanding and properly implementing design patterns is a crucial skill for any software engineer. These patterns provide tested solutions to common problems and can significantly improve code quality and maintainability. However, remember that patterns should be used judiciously - they're tools to solve problems, not goals in themselves.
Keep practicing these patterns, and you'll find yourself writing more maintainable, flexible, and robust code. Whether you're building a new project or maintaining existing code, these patterns will serve as valuable tools in your software engineering toolkit.