Cos'è il pattern Decorator?

Question

Accepted Answer

Il pattern **Decorator** aggiunge dinamicamente **comportamento o responsabilità** agli oggetti avvolgendoli — senza modificare la classe originale. Fornisce un'alternativa flessibile alla subclassing per estendere la funzionalità, permettendoti di comporre comportamenti.

## Cosa fa il pattern Decorator

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

## Esempio

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

## Vantaggi e usi

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

## Perché è importante

Comprendere il pattern Decorator è prezioso perché è un **pattern strutturale utile** per estendere il comportamento in modo flessibile, quindi è una conoscenza di design praticamente rilevante.

Il pattern Decorator aggiunge comportamento agli oggetti **avvolgendoli** (mantenendo la stessa interfaccia, delegando all'originale mentre si aggiunge comportamento), senza modificare la classe originale — fornendo un'alternativa flessibile alla subclassing.

Comprendere cosa fa (avvolgere un oggetto per aggiungere comportamento, con la capacità di **impilare decorator** per comporre più comportamenti) è la conoscenza fondamentale.

Comprendere i **vantaggi** è fondamentale: aggiunge comportamento **senza modificare l'originale** (seguendo il principio open/closed) e evita l'**esplosione di sottoclassi** che risulterebbe dalla creazione di sottoclassi per ogni combinazione di funzionalità, permette di **comporre comportamenti in modo flessibile a runtime** (impilando diversi decorator in varie combinazioni), e supporta la single responsibility (ogni decorator aggiunge una cosa).

Questa composabilità — costruire il comportamento impilando piccoli decorator focalizzati — è il punto di forza del pattern, molto più flessibile della subclassing rigida.

Comprendere gli **usi** — I/O stream (l'esempio classico di avvolgimento di stream), middleware (avvolgimento di handler di richieste — comune nei framework web), componenti UI, aggiunta di funzionalità trasversali (logging, caching, validazione) attorno a un oggetto centrale, e i higher-order component di React — chiarisce la sua ampia applicabilità nel mondo reale.

Il pattern Decorator appare in tutta la realtà di framework e librerie.

Poiché il pattern Decorator è un pattern strutturale utile per estendere il comportamento in modo flessibile (avvolgimento per aggiungere comportamento senza modificare originali o esplosione di subclass, composizione di comportamenti a runtime), e poiché comprendere cosa fa, i suoi vantaggi e i suoi usi comuni (stream, middleware, funzionalità) è praticamente rilevante, comprendere il pattern Decorator è una conoscenza di design preziosa e comunemente applicabile — un pattern utile per l'estensione di comportamento flessibile e componibile, che appare in tutta la realtà di framework (stream, middleware, HOC), e una conoscenza di design importante per estendere la funzionalità in modo pulito senza modificare originali o creare gerarchie di subclass rigide.