Was ist das Strategy-Pattern?

Question

Accepted Answer

Das **Strategy**-Pattern definiert eine Familie von auswechselbaren **Algorithmen/Verhaltensweisen**, kapselt jede ein und macht sie zur Laufzeit austauschbar. Es ermöglicht die dynamische Auswahl eines Algorithmus und vermeidet komplexe Bedingungen, was flexiblen, erweiterbaren Code fördert.

## Was das Strategy-Pattern tut

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

## Beispiel

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

## Vorteile und Anwendungen

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

## Warum es wichtig ist

Das Strategy-Pattern zu verstehen ist wertvoll, da es ein **häufiges, nützliches Verhaltens-Pattern** für flexiblen, erweiterbaren Code ist und daher praktisch relevantes Design-Wissen darstellt.

Das Strategy-Pattern kapselt auswechselbare Algorithmen hinter einer gemeinsamen Schnittstelle und ermöglicht es, Verhaltensweisen zur Laufzeit auszutauschen und dynamisch auszuwählen — es adressiert das häufige Bedürfnis, die *Art und Weise*, wie etwas getan wird, zu variieren, ohne den Code zu ändern, der es nutzt.

Das Verständnis dafür, was es tut (Definition einer Familie von Strategien, die eine gemeinsame Schnittstelle implementieren, wobei der Kontext eine Strategie durch diese Schnittstelle nutzt, sodass Strategien ausgetauscht werden können), ist das Kernwissen.

Das Verständnis der **Vorteile** ist entscheidend: Es ermöglicht es, **Algorithmen zur Laufzeit auszutauschen oder auszuwählen**, **neue Strategien hinzuzufügen, ohne den Kontext zu ändern** (nach dem Open/Closed-Prinzip — erweiterbar ohne Änderung), und besonders **große if/else- oder switch-Anweisungen** auf Typ zu eliminieren (weit verzweigte Bedingungen durch saubere, austauschbare Strategien zu ersetzen — ein häufiges Refactoring, das den Code erheblich verbessert).

Dieser letzte Vorteil ist besonders wertvoll, da das Strategy-Pattern eine saubere Lösung für das häufige Problem von Bedingungslogik ist, die Verhalten auswählt.

Das Verständnis der **Anwendungen** — Zahlungsmethoden, Sortieralgorithmen, Kompression, Validierungsregeln, Preisgestaltung und jede "tue X, aber wie variiert"-Situation — verdeutlicht seine breite Anwendbarkeit.

Das Pattern fördert Komposition statt hardcodierter Bedingungen und führt zu flexiblererem, erweiterbarerem, wartbarerem Code.

Da das Strategy-Pattern ein häufiges, nützliches Verhaltens-Pattern für flexiblen, erweiterbaren Code ist (Algorithmen zur Laufzeit austauschen, Bedingungen eliminieren, Open/Closed-Prinzip befolgen) und da das Verständnis dafür, was es tut, seine Vorteile und seine Anwendungen praktisch relevant für das Schreiben von wartbarem Code ist, ist das Verständnis des Strategy-Patterns wertvoll, häufig anwendbares Design-Wissen — ein häufig nützliches Pattern zum flexiblen Variieren von Verhalten, zum Eliminieren weit verzweigter Bedingungen und zum Befolgen guter Design-Prinzipien, anwendbar in vielen realen Situationen und wichtig für das Schreiben von erweiterbarem, wartbarem Code.