Qu'est-ce que le pattern Décorateur ?

Question

Accepted Answer

Le pattern **Décorateur** ajoute dynamiquement du **comportement ou des responsabilités** aux objets en les enveloppant — sans modifier la classe originale. Il fournit une alternative flexible à l'héritage pour étendre les fonctionnalités, en vous permettant de composer des comportements.

## Ce que fait le pattern Décorateur

```text
DECORATOR → WRAP an object to add behavior, keeping the same interface:
  → the decorator wraps the original, adds its behavior, and delegates to the original
  → you can STACK decorators (wrap a wrapped object) → compose multiple behaviors
  → adds functionality WITHOUT modifying the original class or using subclassing
→ "wrap to extend" — flexible, composable behavior addition
```

## Exemple

```js
// base object
let coffee = { cost: () => 5, description: () => 'coffee' };
// decorators wrap and add behavior
function withMilk(c) {
  return { cost: () => c.cost() + 1, description: () => c.description() + ' + milk' };
}
function withSugar(c) {
  return { cost: () => c.cost() + 0.5, description: () => c.description() + ' + sugar' };
}
coffee = withSugar(withMilk(coffee));   // stack decorators
coffee.cost();          // 6.5 — composed behavior
```

## Avantages et usages

```text
BENEFITS:
  ✓ Add behavior WITHOUT modifying the original (open/closed) or subclass explosion
  ✓ COMPOSE behaviors flexibly at runtime (stack different decorators in combinations)
  ✓ Single responsibility → each decorator adds one thing
USES → I/O streams (wrapping streams), middleware (wrap request handlers), UI components,
  adding features (logging, caching, validation) around a core object; HOC in React
```

## Pourquoi c'est important

Comprendre le pattern Décorateur est précieux car c'est un **pattern structurel utile** pour étendre le comportement de façon flexible, c'est donc une connaissance en matière de conception pratiquement pertinente.

Le pattern Décorateur ajoute du comportement aux objets en les **enveloppant** (en conservant la même interface, en déléguant à l'original tout en ajoutant du comportement), sans modifier la classe originale — fournissant une alternative flexible à l'héritage.

Comprendre ce qu'il fait (envelopper un objet pour ajouter du comportement, avec la capacité de **empiler des décorateurs** pour composer plusieurs comportements) est la connaissance fondamentale.

Comprendre les **avantages** est clé : il ajoute du comportement **sans modifier l'original** (en suivant le principe open/closed) et évite l'**explosion des sous-classes** qui résulterait de la création de sous-classes pour chaque combinaison de fonctionnalités, il vous permet de **composer les comportements de façon flexible à l'exécution** (en empilant différents décorateurs dans diverses combinaisons), et il supporte la responsabilité unique (chaque décorateur ajoutant une chose).

Cette composabilité — en construisant le comportement en empilant de petits décorateurs ciblés — est la force clé du pattern, bien plus flexible que l'héritage rigide.

Comprendre les **usages** — les flux d'E/S (l'exemple classique d'enveloppement de flux), les intergiciels (envelopper les gestionnaires de requêtes — courant dans les frameworks web), les composants UI, l'ajout de fonctionnalités transversales (journalisation, mise en cache, validation) autour d'un objet noyau, et les composants d'ordre supérieur React — clarifie sa large applicabilité dans le monde réel.

Le pattern Décorateur apparaît dans de nombreux frameworks et bibliothèques réels.

Comme le pattern Décorateur est un pattern structurel utile pour étendre le comportement de façon flexible (envelopper pour ajouter du comportement sans modifier les originaux ou créer d'explosion de sous-classes, composer les comportements à l'exécution), et comme comprendre ce qu'il fait, ses avantages et ses usages courants (flux, intergiciels, fonctionnalités) est pratiquement pertinent, comprendre le pattern Décorateur est une connaissance en matière de conception précieuse et couramment applicable — un pattern utile pour l'extension flexible et composable du comportement, apparaissant dans de véritables frameworks (flux, intergiciels, HOC), et une connaissance importante en matière de conception pour étendre les fonctionnalités proprement sans modifier les originaux ou créer des hiérarchies de sous-classes rigides.