O que é o padrão Strategy?

Question

Accepted Answer

O padrão **Strategy** define uma família de **algoritmos/comportamentos** intercambiáveis, encapsula cada um, e os torna permutáveis em tempo de execução. Permite que você selecione um algoritmo dinamicamente e evite condicionais complexas, promovendo código flexível e extensível.

## O que o padrão Strategy faz

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

## Exemplo

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

## Benefícios e usos

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

## Por que isso importa

Compreender o padrão Strategy é valioso porque é um **padrão comportamental comum e útil** para código flexível e extensível, portanto é conhecimento de design praticamente relevante.

O padrão Strategy encapsula algoritmos intercambiáveis por trás de uma interface comum, permitindo que você troque comportamentos em tempo de execução e os selecione dinamicamente — abordando a necessidade comum de variar *como* algo é feito sem alterar o código que o utiliza.

Compreender o que ele faz (definir uma família de estratégias implementando uma interface comum, com o contexto usando uma estratégia através dessa interface para que estratégias possam ser permutadas) é o conhecimento central.

Compreender os **benefícios** é fundamental: permite que você **troque ou selecione algoritmos em tempo de execução**, **adicione novas estratégias sem alterar o contexto** (seguindo o princípio open/closed — estendendo sem modificar), e especialmente **elimine grandes instruções if/else ou switch** sobre tipo (substituindo condicionais espalhadas por estratégias limpas e permutáveis — uma refatoração comum que melhora significativamente o código).

Este último benefício é particularmente valioso, pois o padrão Strategy é uma solução limpa para o problema comum de lógica condicional que seleciona comportamento.

Compreender os **usos** — métodos de pagamento, algoritmos de ordenação, compressão, regras de validação, precificação, e qualquer situação "faça X mas o como varia" — esclarece sua ampla aplicabilidade.

O padrão promove composição sobre condicionais hardcoded, levando a código mais flexível, extensível e maintível.

Como o padrão Strategy é um padrão comportamental comum e útil para código flexível e extensível (permutando algoritmos em tempo de execução, eliminando condicionais, seguindo open/closed), e como compreender o que ele faz, seus benefícios e usos é praticamente relevante para escrever código mantível, compreender o padrão Strategy é conhecimento de design valioso e comumente aplicável — um padrão frequentemente útil para variar comportamento flexivelmente, eliminar condicionais espalhadas, e seguir bons princípios de design, aplicável em muitas situações reais e importante para escrever código extensível e maintível.