What is the Strategy pattern?

Question

Accepted Answer

The **Strategy** pattern defines a family of interchangeable **algorithms/behaviors**, encapsulates each, and makes them swappable at runtime. It lets you select an algorithm dynamically and avoid complex conditionals, promoting flexible, extensible code.

## What the Strategy pattern does

```text
STRATEGY → encapsulate INTERCHANGEABLE algorithms/behaviors behind a common interface:
  → define a family of strategies (each implements the same interface)
  → the context uses a strategy via the interface → can SWAP strategies at runtime
  → choose the behavior dynamically without changing the context
→ "compose" behavior instead of hardcoding it (favor composition over conditionals)
```

## Example

```js
// different payment strategies, interchangeable
class CreditCardStrategy { pay(amount) { /* ... */ } }
class PayPalStrategy { pay(amount) { /* ... */ } }

class Checkout {
  constructor(strategy) { this.strategy = strategy; }   // inject a strategy
  process(amount) { this.strategy.pay(amount); }         // use it via the interface
}
new Checkout(new PayPalStrategy()).process(100);   // swap strategy easily
```

## Benefits and uses

```text
BENEFITS:
  ✓ Swap/select algorithms at RUNTIME; add new strategies without changing the context
  ✓ Eliminates big if/else or switch on "type" (replace conditionals with strategies)
  ✓ Open/closed → extend with new strategies without modifying existing code
USES → payment methods, sorting algorithms, compression, validation rules, pricing,
  any "do X but the HOW varies" situation
```

## Why it matters

Understanding the Strategy pattern is valuable because it's a **common, useful behavioral pattern** for flexible, extensible code, so it's practically-relevant design knowledge.

The Strategy pattern encapsulates interchangeable algorithms behind a common interface, letting you swap behaviors at runtime and select them dynamically — addressing the common need to vary *how* something is done without changing the code that uses it.

Understanding what it does (defining a family of strategies implementing a common interface, with the context using a strategy through that interface so strategies can be swapped) is the core knowledge.

Understanding the **benefits** is key: it lets you **swap or select algorithms at runtime**, **add new strategies without changing the context** (following the open/closed principle — extending without modifying), and especially **eliminate big if/else or switch statements** on type (replacing sprawling conditionals with clean, swappable strategies — a common refactoring that improves code significantly).

This last benefit is particularly valuable, as the Strategy pattern is a clean solution to the common problem of conditional logic that selects behavior.

Understanding the **uses** — payment methods, sorting algorithms, compression, validation rules, pricing, and any "do X but the how varies" situation — clarifies its broad applicability.

The pattern promotes composition over hardcoded conditionals, leading to more flexible, extensible, maintainable code.

Since the Strategy pattern is a common, useful behavioral pattern for flexible, extensible code (swapping algorithms at runtime, eliminating conditionals, following open/closed), and since understanding what it does, its benefits, and its uses is practically relevant for writing maintainable code, understanding the Strategy pattern is valuable, commonly-applicable design knowledge — a frequently-useful pattern for varying behavior flexibly, eliminating sprawling conditionals, and following good design principles, applicable in many real situations and important for writing extensible, maintainable code.