Padrões de projeto: Strategy, Observer e Factory

Três padrões de projeto que aparecem o tempo todo no código JavaScript, Strategy pra trocar comportamento, Observer pra reagir a eventos e Factory pra centralizar a criação de objetos, com exemplos práticos.


Padrões de projeto têm fama de coisa acadêmica, cheia de diagramas e nomes pomposos. Na prática, são soluções que desenvolvedores reinventaram muitas vezes pra problemas que se repetem. Conhecer o nome ajuda a reconhecer o problema e a conversar sobre ele. E vários você já usa sem saber.

Vou mostrar três que aparecem em código do dia a dia.

Strategy: trocar o comportamento sem if gigante

O problema: uma função que faz coisas diferentes dependendo de um tipo, com uma cadeia de if/else que cresce a cada novo caso.

function calcularFrete(tipo, peso) {
  if (tipo === "padrao") return peso * 2;
  if (tipo === "expresso") return peso * 5 + 10;
  if (tipo === "retirada") return 0;
  throw new Error("Tipo inválido");
}

Cada novo tipo de frete obriga a editar essa função, arriscando quebrar os existentes. Com Strategy, cada comportamento vira uma função independente, e o código escolhe qual usar:

const estrategiasDeFrete = {
  padrao: (peso) => peso * 2,
  expresso: (peso) => peso * 5 + 10,
  retirada: () => 0,
};
 
function calcularFrete(tipo, peso) {
  const estrategia = estrategiasDeFrete[tipo];
  if (!estrategia) throw new Error("Tipo inválido");
  return estrategia(peso);
}

Adicionar "agendado" agora é só incluir uma entrada no objeto, sem tocar na lógica que já funciona. É o princípio aberto/fechado do SOLID aplicado: aberto pra extensão, fechado pra modificação.

Onde aparece: formas de pagamento, regras de desconto, algoritmos de ordenação, estratégias de autenticação (o Passport.js é basicamente isso).

Observer: reagir quando algo acontece

O problema: uma parte do sistema precisa avisar outras quando algo muda, sem conhecê-las diretamente. Se o código de "pedido criado" chamar sozinho o envio de e-mail, a atualização do estoque e o registro de analytics, ele fica acoplado a tudo isso.

Com Observer, quem gera o evento só avisa, e quem se interessa se inscreve:

class EmissorDeEventos {
  constructor() {
    this.ouvintes = {};
  }
 
  ouvir(evento, funcao) {
    (this.ouvintes[evento] ||= []).push(funcao);
  }
 
  emitir(evento, dados) {
    (this.ouvintes[evento] || []).forEach((funcao) => funcao(dados));
  }
}
 
const eventos = new EmissorDeEventos();
 
eventos.ouvir("pedido-criado", (pedido) => enviarEmail(pedido));
eventos.ouvir("pedido-criado", (pedido) => baixarEstoque(pedido));
eventos.ouvir("pedido-criado", (pedido) => registrarAnalytics(pedido));
 
function criarPedido(dados) {
  const pedido = salvar(dados);
  eventos.emitir("pedido-criado", pedido);
  return pedido;
}

criarPedido não sabe quem reage, e novas reações entram sem mexer nele. Esse padrão está espalhado: o addEventListener do navegador, o EventEmitter do Node, o subscribe do Zustand e do Redux, os eventos de um webhook. Em escala maior, vira mensageria, como no post sobre filas.

Cuidado: muitos ouvintes escondem o fluxo, e fica difícil responder "o que acontece quando o pedido é criado?". Também é preciso remover ouvintes que não são mais necessários, senão sobra vazamento de memória.

Factory: centralizar a criação

O problema: criar objetos de tipos parecidos, com configuração que varia, espalha new e if por todo lado.

function criarNotificador(canal) {
  switch (canal) {
    case "email":
      return { enviar: (msg) => enviarPorEmail(msg) };
    case "sms":
      return { enviar: (msg) => enviarPorSms(msg) };
    case "push":
      return { enviar: (msg) => enviarPorPush(msg) };
    default:
      throw new Error(`Canal desconhecido: ${canal}`);
  }
}
 
const notificador = criarNotificador(usuario.canalPreferido);
notificador.enviar("Seu pedido saiu");

Quem usa o notificador não precisa saber como cada um é construído, só que todos têm o método enviar. Trocar ou adicionar um canal muda um lugar só.

Onde aparece: React.createElement, clientes de banco de dados que escolhem o driver pelo tipo, provedores configuráveis por variável de ambiente (e-mail local em desenvolvimento, serviço real em produção).

Como usar padrões sem exagero

  • Comece pelo problema. Padrão não é meta. Se não há if crescendo, acoplamento incômodo ou criação repetitiva, não precisa de nada disso.
  • Espere a repetição. Com um único caso, uma função simples basta. Na terceira variação, o padrão se justifica.
  • Em JavaScript, prefira o simples. Muitos padrões clássicos foram pensados pra linguagens com classes pesadas. Aqui, um objeto de funções já é um Strategy, e funções são cidadãs de primeira classe.

Fechando

Strategy troca comportamento sem if gigante, Observer desacopla quem avisa de quem reage, e Factory concentra a criação de objetos. Nenhum é obrigatório, mas conhecer os três dá vocabulário pra reconhecer o problema quando ele aparecer, e pra explicar a solução pro time em uma frase.

Direto na sua
caixa de entrada.

Um aviso por e-mail sempre que eu publicar um post novo. Sem spam, sem newsletter chata, só isso.