Vad är Strategy-mönstret?

Question

Accepted Answer

**Strategy**-mönstret definierar en familj av utbytbara **algoritmer/beteenden**, kapslar in var och en, och gör dem utbytbara vid körning. Det låter dig välja en algoritm dynamiskt och undvika komplexa villkor, vilket främjar flexibel, utvidgbar kod.

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

## Exempel

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

## Fördelar och användningsområden

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

## Varför det är viktigt

Att förstå Strategy-mönstret är värdefullt eftersom det är ett **vanligt, användbart beteendemönster** för flexibel, utvidgbar kod, så det är praktiskt relevant designkunskap.

Strategy-mönstret kapslar in utbytbara algoritmer bakom ett gemensamt gränssnitt, vilket låter dig byta beteenden vid körning och välja dem dynamiskt — detta löser det vanliga behovet att variera *hur* något görs utan att ändra koden som använder det.

Att förstå vad det gör (definierar en familj av strategier som implementerar ett gemensamt gränssnitt, där kontexten använder en strategi genom det gränssnittet så strategier kan bytas) är kärnkunskapen.

Att förstå **fördelarna** är nyckeln: det låter dig **byta eller välja algoritmer vid körning**, **lägga till nya strategier utan att ändra kontexten** (följer open/closed-principen — utöka utan att ändra), och särskilt **eliminera stora if/else eller switch-satser** på typ (ersätta utbredda villkor med rena, utbytbara strategier — en vanlig refaktorering som förbättrar koden betydligt).

Den sistnämnda fördelen är särskilt värdefull, eftersom Strategy-mönstret är en ren lösning på det vanliga problemet med villkorlig logik som väljer beteende.

Att förstå **användningsområdena** — betalningsmetoder, sorteringsalgoritmer, komprimering, valideringsregler, prissättning och alla "gör X men hur varierar"-situationer — klargör dess breda tillämpbarhet.

Mönstret främjar komposition över hårdkodad villkorlig logik, vilket leder till mer flexibel, utvidgbar, underhållsbar kod.

Eftersom Strategy-mönstret är ett vanligt, användbart beteendemönster för flexibel, utvidgbar kod (byta algoritmer vid körning, eliminera villkor, följa open/closed-principen), och eftersom att förstå vad det gör, dess fördelar och dess användningsområden är praktiskt relevant för att skriva underhållsbar kod, är att förstå Strategy-mönstret värdefullt, allmänt tillämpbar designkunskap — ett ofta användbart mönster för att variera beteende flexibelt, eliminera utbredda villkor och följa bra designprinciper, tillämpbart i många verkliga situationer och viktigt för att skriva utvidgbar, underhållsbar kod.