Strategy Pattern

Definition

The Strategy Pattern is a behavioral design pattern that enables selecting an algorithm's behavior at runtime. It defines a family of algorithms, encapsulates each one, and makes them interchangeable. The Strategy Pattern allows the algorithm to vary independently from clients that use it.

Structure

The core components of the Strategy Pattern include:

• Context: Maintains a reference to a Strategy class and calls the algorithm defined by a Strategy.
• Strategy Interface: Common interface for all concrete strategies.
• Concrete Strategies: Classes that implement the Strategy interface, defining specific algorithms.

Implementation

class Strategy {
    execute(a, b) {}
}

class ConcreteStrategyAdd extends Strategy {
    execute(a, b) {
        return a + b;
    }
}

class ConcreteStrategySubtract extends Strategy {
    execute(a, b) {
        return a - b;
    }
}

class Context {
    constructor(strategy) {
        this.strategy = strategy;
    }

    setStrategy(strategy) {
        this.strategy = strategy;
    }

    executeStrategy(a, b) {
        return this.strategy.execute(a, b);
    }
}

// Usage
const context = new Context(new ConcreteStrategyAdd());
console.log(context.executeStrategy(5, 3)); // Outputs: 8

context.setStrategy(new ConcreteStrategySubtract());
console.log(context.executeStrategy(5, 3)); // Outputs: 2
            

Best Practices

When implementing the Strategy Pattern, consider the following:

• Ensure that the Strategy interface is designed to accommodate various algorithms.
• Limit the number of strategies to avoid excessive complexity.
• Use the Strategy Pattern when you need to switch between algorithms dynamically.