Wat is het Strategy-patroon?

Question

Accepted Answer

Het **Strategy**-patroon definieert een familie van uitwisselbare **algoritmes/gedragingen**, encapsuleert elk daarvan, en maakt ze verwisselbaar tijdens runtime. Het laat je dynamisch een algoritme selecteren en complexe voorwaardelijke statements vermijden, wat flexibele en uitbreidbare code bevordert.

## Wat het Strategy-patroon doet

```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)
```

## Voorbeeld

```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
```

## Voordelen en toepassingen

```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
```

## Waarom het belangrijk is

Het begrijpen van het Strategy-patroon is waardevol omdat het een **veelgebruikt, nuttig gedragspatroon** is voor flexibele, uitbreidbare code, dus het is praktisch relevante ontwerpkennis.

Het Strategy-patroon encapsuleert uitwisselbare algoritmes achter een gemeenschappelijke interface, zodat je gedragingen tijdens runtime kunt verwisselen en dynamisch kunt selecteren — dit adresseert de veelvoorkomende behoefte om *hoe* iets wordt gedaan aan te passen zonder de code die het gebruikt te wijzigen.

Begrijpen wat het doet (een familie van strategieën definiëren die een gemeenschappelijke interface implementeren, waarbij de context een strategie via die interface gebruikt zodat strategieën kunnen worden verwisseld) is de kernkennis.

Het begrijpen van de **voordelen** is essentieel: het laat je **algoritmes tijdens runtime verwisselen of selecteren**, **nieuwe strategieën toevoegen zonder de context te wijzigen** (volgens het open/gesloten principe — uitbreiden zonder aan te passen), en vooral **grote if/else of switch-statements op type elimineren** (uitgebreide voorwaardelijke statements vervangen door schone, verwisselbare strategieën — een veelvoorkomende refactoring die code aanzienlijk verbetert).

Dit laatste voordeel is bijzonder waardevol, omdat het Strategy-patroon een schone oplossing is voor het veelvoorkomende probleem van voorwaardelijke logica die gedrag selecteert.

Het begrijpen van de **toepassingen** — betaalmethoden, sorteeralgoritmes, compressie, validatieregels, prijsstelling, en elke "voer X uit maar hoe varieert" situatie — verduidelijkt de brede toepasbaarheid ervan.

Het patroon bevordert compositie boven hardgecodeerde voorwaarden, wat leidt tot meer flexibele, uitbreidbare en onderhoudsbare code.

Omdat het Strategy-patroon een veelgebruikt, nuttig gedragspatroon is voor flexibele, uitbreidbare code (algoritmes tijdens runtime verwisselen, voorwaarden elimineren, open/gesloten principe volgen), en omdat het begrijpen wat het doet, de voordelen ervan, en de toepassingen ervan praktisch relevant is voor het schrijven van onderhoudsbare code, is het begrijpen van het Strategy-patroon waardevol en veeltoepasbaar ontwerpkennis — een veel gebruikt patroon voor flexibel gedrag variëren, het elimineren van uitgebreide voorwaarden, en het volgen van goede ontwerpprincipes, toepasbaar in veel echte situaties en belangrijk voor het schrijven van uitbreidbare, onderhoudsbare code.