Hvad er Strategy-mønstret?

Question

Accepted Answer

**Strategy**-mønstret definerer en familie af udskiftelige **algoritmer/adfærd**, indkapsler hver enkelt og gør dem udskiftelige ved runtime. Det lader dig vælge en algoritme dynamisk og undgå komplekse betingelser, hvilket fremmer fleksibel, udvidbar kode.

## Hvad Strategy-mønstret gør

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

## Eksempel

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

## Fordele og anvendelser

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

## Hvorfor det betyder noget

At forstå Strategy-mønstret er værdifuldt, fordi det er et **hyppigt, brugbart opførselsmønster** for fleksibel, udvidbar kode, så det er praktisk relevant designviden.

Strategy-mønstret indkapsler udskiftelige algoritmer bag en fælles interface, som lader dig skifte adfærd ved runtime og vælge dem dynamisk — og løser det hyppige behov for at variere *hvordan* noget gøres uden at ændre koden, der bruger det.

At forstå, hvad det gør (definere en familie af strategier, der implementerer en fælles interface, hvor konteksten bruger en strategi gennem den interface, så strategier kan skiftes), er kernekendskabet.

At forstå **fordelene** er nøglen: det lader dig **skifte eller vælge algoritmer ved runtime**, **tilføje nye strategier uden at ændre konteksten** (følger open/closed-princippet — udvidelse uden ændring), og især **eliminere store if/else eller switch-udsagn** på type (erstatte omfattende betingelser med rene, udskiftelige strategier — en hyppig refactoring, der forbedrer koden markant).

Denne sidste fordel er særlig værdifuld, da Strategy-mønstret er en ren løsning på det hyppige problem med betinget logik, der vælger adfærd.

At forstå **anvendelserne** — betalingsmetoder, sorteringsalgoritmer, kompression, valideringsregler, prissætning og enhver "gør X, men hvordan varierer"-situation — præciserer dets brede anvendelighed.

Mønstret fremmer komposition frem for hardcodede betingelser, hvilket fører til mere fleksibel, udvidbar, vedligeholdelig kode.

Da Strategy-mønstret er et hyppigt, brugbart opførselsmønster for fleksibel, udvidbar kode (skifter algoritmer ved runtime, eliminerer betingelser, følger open/closed), og da forståelse af, hvad det gør, dets fordele og dets anvendelser er praktisk relevant for at skrive vedligeholdelig kode, er forståelse af Strategy-mønstret værdifuld, almindeligt anvendelig designviden — et hyppigt nyttigt mønster for at variere adfærd fleksibelt, eliminere omfattende betingelser og følge gode designprincipper, som kan anvendes i mange virkelige situationer og er vigtig for at skrive udvidbar, vedligeholdelig kode.