Como Substituir if/else com o Object Literal Pattern em JavaScript

Se você programa em JavaScript há algum tempo, provavelmente já se viu preso em um bloco enorme de if/else ou switch/case que parece não ter fim.
Eu já passei por isso várias vezes — e, para ser sincero, dá aquela sensação de “meu código poderia estar mais limpo”.

Um dos recursos que comecei a usar e que mudou bastante meu jeito de escrever código é o Object Literal Pattern (ou Object Lookup Pattern, se preferir).

---

Sumário

1. O Problema: Condições demais
2. A Solução: Object Literal Pattern
3. Um Exemplo Real: Calculadora
4. Por que vale a pena usar
5. Quando funciona melhor
6. Conclusão

---

O Problema: Condições demais

Um caso real que encontrei foi ao lidar com comandos para um sistema.
Inicialmente, meu código era algo assim:

const action = "update";

if (action === "create") {
  console.log("Criando...");
} else if (action === "update") {
  console.log("Atualizando...");
} else if (action === "delete") {
  console.log("Deletando...");
} else {
  console.log("Ação inválida");
}

Funciona. Mas conforme as ações aumentam, esse formato vira um monstro para manter.
Se precisar mudar algo, você tem que caçar dentro de uma lista interminável de condições.

---

A Solução: Object Literal Pattern

A ideia é simples: em vez de ficar criando uma série de if/else, você cria um objeto onde cada chave representa uma condição e o valor é a função que trata aquela condição.

const actions = {
  create: () => console.log("Criando..."),
  update: () => console.log("Atualizando..."),
  delete: () => console.log("Deletando...")
};

const action = "update";

// Executa a ação, ou mostra mensagem de erro se não existir
(actions[action] || (() => console.log("Ação inválida")))();

Dessa forma:

• Cada chave (create, update, delete) é um caso.
• O valor é uma função que contém a lógica.
• Se não existir, cai no fallback.

Além de mais limpo, fica muito mais fácil adicionar, remover ou alterar casos.

---

Um Exemplo Real: Calculadora

Eu uso bastante essa abordagem em pequenas utilidades, como uma função de cálculo:

Com if/else:

function calculate(op, a, b) {
  if (op === "sum") return a + b;
  if (op === "sub") return a - b;
  if (op === "mul") return a * b;
  if (op === "div") return b !== 0 ? a / b : "Erro: divisão por zero";
  return "Operação inválida";
}

console.log(calculate("mul", 5, 3)); // 15

Com Object Literal Pattern:

const operations = {
  sum: (a, b) => a + b,
  sub: (a, b) => a - b,
  mul: (a, b) => a * b,
  div: (a, b) => (b !== 0 ? a / b : "Erro: divisão por zero"),
};

function calculate(op, a, b) {
  return (operations[op] || (() => "Operação inválida"))(a, b);
}

console.log(calculate("mul", 5, 3)); // 15

Percebe a diferença? Agora, se eu quiser criar um mod para resto da divisão, basta adicionar mais uma chave no objeto.

---

Por que vale a pena usar

• O código fica mais legível
• É fácil de manter
• Você pode adicionar casos sem quebrar nada
• Dá para separar o objeto em outro arquivo e até reaproveitar

---

Quando funciona melhor

Esse padrão brilha quando:

• Você tem muitos casos fixos
• Cada caso é uma ação pequena e independente
• Você quer evitar estruturas repetitivas de controle de fluxo

---

Conclusão

Essa técnica é simples, mas já me salvou muito tempo e me ajudou a evitar bugs em código com muitos casos.
Sempre que vejo um if/else enorme, já penso:

“Isso aqui cabe em um Object Literal?”

Vale lembrar que esse padrão é como um “primo simplificado” do Strategy Pattern, só que usando objetos literais.