Qu'est-ce que le pattern Strategy ?

Question

Accepted Answer

Le pattern **Strategy** définit une famille **d'algorithmes/comportements** interchangeables, encapsule chacun, et les rend interchangeables à l'exécution. Il vous permet de sélectionner un algorithme dynamiquement et d'éviter les conditionnelles complexes, en favorisant un code flexible et extensible.

## Ce que fait le pattern Strategy

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

## Exemple

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

## Avantages et utilisations

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

## Pourquoi c'est important

Comprendre le pattern Strategy est précieux car c'est un **pattern comportemental courant et utile** pour un code flexible et extensible, ce qui en fait une connaissance de conception pratiquement pertinente.

Le pattern Strategy encapsule les algorithmes interchangeables derrière une interface commune, vous permettant de changer les comportements à l'exécution et de les sélectionner dynamiquement — répondant au besoin courant de varier *comment* quelque chose est fait sans modifier le code qui l'utilise.

Comprendre ce qu'il fait (définir une famille de stratégies implémentant une interface commune, avec le contexte utilisant une stratégie à travers cette interface afin que les stratégies puissent être échangées) est la connaissance centrale.

Comprendre les **avantages** est clé : il vous permet **d'échanger ou sélectionner les algorithmes à l'exécution**, **d'ajouter de nouvelles stratégies sans modifier le contexte** (suivant le principe ouvert/fermé — extension sans modification), et surtout **d'éliminer les grands if/else ou switch statements** sur le type (remplaçant les conditionnelles dispersées par des stratégies propres et interchangeables — une refactorisation courante qui améliore considérablement le code).

Cet dernier avantage est particulièrement précieux, car le pattern Strategy est une solution propre au problème courant de logique conditionnelle qui sélectionne le comportement.

Comprendre les **utilisations** — méthodes de paiement, algorithmes de tri, compression, règles de validation, tarification, et toute situation "faire X mais le comment varie" — clarifie son large applicabilité.

Le pattern favorise la composition plutôt que les conditionnelles codées en dur, menant à un code plus flexible, extensible et maintenable.

Puisque le pattern Strategy est un pattern comportemental courant et utile pour un code flexible et extensible (échanger les algorithmes à l'exécution, éliminer les conditionnelles, suivre le principe ouvert/fermé), et puisque comprendre ce qu'il fait, ses avantages et ses utilisations est pratiquement pertinent pour écrire du code maintenable, comprendre le pattern Strategy est une connaissance de conception précieuse et couramment applicable — un pattern fréquemment utile pour varier le comportement de manière flexible, éliminer les conditionnelles dispersées, et suivre les bons principes de conception, applicable dans de nombreuses situations réelles et important pour écrire du code extensible et maintenable.