Aula 74 — Promises e async/await (por baixo do capô)

Até aqui, já entendemos:

• Como o JavaScript executa código
• Call Stack e Execution Context
• Event Loop
• Microtasks e Macrotasks

Agora chegou a hora de entender por que Promises existem — e por que async/await não é “mágica”.

🎯 Objetivo da aula

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

• Entender o problema que Promises resolvem
• Compreender o estado interno de uma Promise
• Saber como then, catch e finally funcionam
• Entender o que o async/await faz por baixo do capô
• Parar de tratar Promises como “caixa preta”

O problema original: callbacks

Antes das Promises, o JavaScript lidava com assincronicidade usando callbacks.

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

Problemas:

• Código difícil de ler
• Difícil de tratar erros
• Difícil de manter

O que é uma Promise?

Uma Promise representa:

um valor que ainda não existe, mas vai existir no futuro (ou falhar).

Ela é um objeto que pode estar em três estados:

• pending (pendente)
• fulfilled (resolvida)
• rejected (rejeitada)

Criando uma Promise manualmente

 
  const promessa = new Promise((resolve, reject) => 
  { 
    const sucesso = true;
    if (sucesso) 
      {
        resolve("Deu certo!");
      } 
      else 
        {
          reject("Deu errado!");
        }
  });

Consumindo essa Promise:

 promessa .then(resultado => { console.log(resultado); }) .catch(erro => { console.log(erro); }); 

 console.log(resultado); // Saída será: Deu certo! 

O papel do .then()

O then:

• é chamado quando a Promise é resolvida
• entra na Microtask Queue
• não executa imediatamente

Isso conecta diretamente com tudo que vimos sobre Event Loop.

Encadeamento de Promises

 
  Promise.resolve(2) .then(numero => numero * 2) .then(resultado => 
  { 
    console.log(resultado); 
  }); 

 console.log(resultado); // Saída será: 4 

Tratando erros corretamente

 
  Promise.resolve() .then(() => 
  { 
    throw new Error("Erro inesperado"); 
  }) .catch(erro => 
  { 
    console.log(erro.message); 
  }); 

 console.log(erro.message); // Saída será: Erro inesperado 

Um catch captura qualquer erro anterior no encadeamento.

Então… o que é async/await?

async/await é:

açúcar sintático em cima de Promises.

Nada mais.

Exemplo com async/await

 
  async function buscarDados() 
  { 
    const resultado = await Promise.resolve("Dados carregados"); 
    console.log(resultado); 
  }
  buscarDados();

 console.log(resultado); // Saída será: Dados carregados 

O que o await faz de verdade?

Quando o JavaScript encontra um await:

• A função é pausada
• O Call Stack é liberado
• A Promise continua sendo processada
• A continuação vira uma microtask

Async/await com try/catch

 
  async function executar() 
  { 
    try { 
      const resultado = await Promise.reject("Falhou"); 
      console.log(resultado); 
    } 
    catch (erro) 
    { 
      console.log(erro); 
    } 
  }

executar();

 console.log(erro); // Saída será: Falhou 

Comparação mental importante

• Promise → controle explícito
• async/await → leitura sequencial
• Ambos usam microtasks
• Ambos respeitam o Event Loop

Na próxima aula, vamos aplicar Promises e async/await em cenários reais, conectando com APIs, erros e fluxo de dados.