O que é o padrão Decorator?

Question

Accepted Answer

O padrão **Decorator** adiciona dinamicamente **comportamento ou responsabilidades** a objetos envolvendo-os — sem modificar a classe original. Ele fornece uma alternativa flexível à herança para estender funcionalidade, permitindo que você componha comportamentos.

## O que o padrão Decorator faz

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

## Exemplo

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

## Benefícios e usos

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

## Por que isso importa

Entender o padrão Decorator é valioso porque é um **padrão estrutural útil** para estender comportamento de forma flexível, então é conhecimento de design praticamente relevante.

O padrão Decorator adiciona comportamento a objetos **envolvendo-os** (mantendo a mesma interface, delegando ao original enquanto adiciona comportamento), sem modificar a classe original — fornecendo uma alternativa flexível à herança.

Entender o que ele faz (envolver um objeto para adicionar comportamento, com a capacidade de **empilhar decoradores** para compor múltiplos comportamentos) é o conhecimento central.

Entender os **benefícios** é fundamental: adiciona comportamento **sem modificar o original** (seguindo o princípio aberto/fechado) e evita a **explosão de subclasses** que resultaria de criar subclasses para cada combinação de recursos, permite **compor comportamentos flexivelmente em tempo de execução** (empilhando diferentes decoradores em várias combinações), e suporta responsabilidade única (cada decorador adicionando uma coisa).

Essa composição — construindo comportamento empilhando decoradores pequenos e focados — é o ponto forte do padrão, muito mais flexível do que herança rígida.

Entender os **usos** — streams de I/O (o exemplo clássico de envolver streams), middleware (envolvendo manipuladores de requisições — comum em frameworks web), componentes de UI, adicionar recursos transversais (logging, caching, validação) em torno de um objeto central, e Higher-Order Components do React — esclarece sua ampla aplicabilidade no mundo real.

O padrão Decorator aparece em frameworks e bibliotecas reais.

Como o padrão Decorator é um padrão estrutural útil para estender comportamento de forma flexível (envolver para adicionar comportamento sem modificar originais ou explosão de subclasses, compor comportamentos em tempo de execução), e como entender o que ele faz, seus benefícios e seus usos comuns (streams, middleware, recursos) é praticamente relevante, entender o padrão Decorator é conhecimento de design valioso, comumente aplicável — um padrão útil para extensão de comportamento flexível e composável, aparecendo em frameworks reais (streams, middleware, HOCs), e conhecimento de design importante para estender funcionalidade de forma limpa sem modificar originais ou criar hierarquias de subclasses rígidas.