Aula 75 — Desmistificando Promises e async/await

Até aqui, vimos exemplos com Promises que, à primeira vista, parecem desnecessários.

Isso levanta uma dúvida muito justa:

“Isso não poderia ser feito com uma função simples?”

Nesta aula, vamos responder essa pergunta com exemplos reais — mostrando situações onde:

• Funções simples funcionam
• Funções simples quebram
• Promises resolvem
• async/await simplifica drasticamente

🎯 Objetivo da aula

Ao final desta aula, você será capaz de:

• Saber quando uma função simples é suficiente
• Entender quando Promises são necessárias
• Reconhecer problemas assíncronos reais
• Usar async/await para reduzir complexidade

Caso 1 — Função simples funciona

Quando tudo acontece imediatamente, uma função simples é perfeita.

 
  function dobrar(numero) { 
    return numero * 2; 
  }
  console.log(dobrar(4)); // Saída será 8

Aqui:

• Não há espera
• Não há erro assíncrono
• Não há dependência externa

👉 **Promises seriam exagero.**

Caso 2 — Função simples quebra

Agora imagine um dado que só chega depois.

 
  function buscarUsuario() 
  { 
    setTimeout(() => 
    { return 
    { nome: "Daniel" }; 
    }, 1000); 
  }
  const usuario = buscarUsuario();
  console.log(usuario);

 console.log(usuario); // Saída será undefined 

Por quê?

• O return acontece dentro do callback
• A função termina antes do dado existir

👉 **Aqui a função simples falha.**

Caso 3 — Promise resolve o problema

Agora o mesmo problema resolvido corretamente:

 
  function buscarUsuario() 
  { 
    return new Promise(resolve => 
    { 
      setTimeout(() => 
      { 
        resolve({ nome: "Daniel" }); 
      }, 1000); 
    }); 
  }
  buscarUsuario().then(usuario => 
  {
    console.log(usuario.nome); // Saída será Daniel
  });

Aqui:

• A função retorna imediatamente
• Mas o valor só chega quando estiver pronto

Caso 4 — Encadeamento sem Promise vira caos

Imagine múltiplas operações dependentes:

 
  buscarUsuario(function (usuario) 
  { 
    buscarPedidos(usuario.id, function (pedidos) 
    { 
      buscarDetalhes(pedidos[0], function (detalhes) 
      { 
        console.log(detalhes); 
      }); 
    }); 
  }); 

Caso 5 — Promises organizam o fluxo

  buscarUsuario() .then(usuario => buscarPedidos(usuario.id)) .then(pedidos => buscarDetalhes(pedidos[0])) .then(detalhes => 
  { 
    console.log(detalhes); 
  }) .catch(erro => 
  { 
    console.log("Erro:", erro); 
  }); 

O fluxo agora é:

• Linear
• Legível
• Com tratamento de erro centralizado

Caso 6 — async/await simplifica ainda mais

O mesmo código com async/await:

 
  async function executar() 
  { 
    try 
    { 
      const usuario = await buscarUsuario(); 
      const pedidos = await buscarPedidos(usuario.id); 
      const detalhes = await buscarDetalhes(pedidos[0]);
      console.log(detalhes);
    } catch (erro) 
    {
      console.log("Erro:", erro);
    }
  }
  executar();

Agora:

• Fluxo parece síncrono
• Mas continua assíncrono
• Mais fácil de ler
• Mais fácil de manter

Comparação honesta

• Função simples → dados imediatos
• Promise → dados futuros
• async/await → Promises legíveis

Na próxima aula, vamos aplicar async/await em cenários reais com fetch, erros de rede e controle de fluxo completo.