Hva er Strategy-mønsteret?

Question

Accepted Answer

**Strategy**-mønsteret definerer en familie av utvekslbare **algoritmer/atferd**, innkapsler hver enkelt, og gjør dem utbyttbare under kjøring. Det lar deg velge en algoritme dynamisk og unngå komplekse betingelser, noe som fremmer fleksibel, utvidbar kode.

## Hva Strategy-mønsteret gjø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
```

## Fordeler og bruksområder

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

Å forstå Strategy-mønsteret er verdifull fordi det er et **vanlig, nyttig atferdsmønster** for fleksibel, utvidbar kode, og derfor praktisk relevant designkunnskap.

Strategy-mønsteret innkapsler utvekslbare algoritmer bak et felles grensesnitt, noe som lar deg bytte atferd under kjøring og velge dem dynamisk — og adresserer det vanlige behovet for å variere *hvordan* noe gjøres uten å endre koden som bruker det.

Å forstå hva det gjør (å definere en familie av strategier som implementerer et felles grensesnitt, med konteksten som bruker en strategi gjennom det grensesnittet slik at strategier kan byttes ut) er kjernekunnskap.

Å forstå **fordelene** er nøkkelen: det lar deg **bytte eller velge algoritmer under kjøring**, **legge til nye strategier uten å endre konteksten** (følge åpen/lukket prinsippet — utvide uten å modifisere), og spesielt **eliminere store if/else eller switch-setninger** basert på type (erstatte omfattende betingelser med rene, utbyttbare strategier — en vanlig refaktorering som forbedrer koden betydelig).

Denne siste fordelen er særlig verdifull, ettersom Strategy-mønsteret er en ren løsning på det vanlige problemet med betingelseslogikk som velger atferd.

Å forstå **bruksområdene** — betalingsmetoder, sorteringsalgoritmer, komprimering, valideringsregler, prissetting, og enhver "gjør X men hvordan varierer" situasjon — avklarer dens brede anvendelighet.

Mønsteret fremmer komposisjon fremfor hardkodet betingelser, noe som fører til mer fleksibel, utvidbar, vedlikeholdbar kode.

Ettersom Strategy-mønsteret er et vanlig, nyttig atferdsmønster for fleksibel, utvidbar kode (bytte algoritmer under kjøring, eliminere betingelser, følge åpen/lukket prinsippet), og ettersom å forstå hva det gjør, dets fordeler og bruksområder er praktisk relevant for å skrive vedlikeholdbar kode, er forståelse av Strategy-mønsteret verdifull, alminnelig anvendelig designkunnskap — et hyppig nyttig mønster for å variere atferd fleksibelt, eliminere omfattende betingelser, og følge gode designprinsipper, anvendelig i mange virkelige situasjoner og viktig for å skrive utvidbar, vedlikeholdbar kode.