Async/Await: o jeito 'moderno' de escrever código assíncrono

Você já viu callbacks e Promises.
Agora chegou a forma mais legível de trabalhar com assincronicidade: async/await.

Pense assim:
async/await deixa o código com “cara de síncrono”, mesmo sendo assíncrono por baixo.

Ideia principal

• async transforma uma função em assíncrona (ela sempre retorna uma Promise).
• await “espera” a Promise resolver, sem travar a interface do usuário.

Exemplo básico

function esperar2s() {
  return new Promise(function (resolve) {
    setTimeout(function () {
      resolve("Terminou!");
    }, 2000);
  });
}

async function executar() {
  console.log("Início");
  const resultado = await esperar2s();
  console.log(resultado);
  console.log("Fim");
}

executar();

O que acontece?

1. A função executar começa.
2. await esperar2s() aguarda o resultado da Promise.
3. Quando resolve, continua para as próximas linhas.

Regras importantes

1) await só funciona dentro de função async

async function carregar() {
  const dados = await Promise.resolve("OK");
  console.log(dados);
}

Se tentar usar await fora de função async (em contexto comum), dá erro de sintaxe.

2) async sempre retorna Promise

async function exemplo() {
  return 42;
}

exemplo().then(function (valor) {
  console.log(valor); // 42
});

Mesmo retornando número, por trás vem em formato de Promise resolvida.

Tratando erros com try...catch

Com async/await, o tratamento de erro fica bem natural:

function buscarUsuario() {
  return Promise.reject("Falha ao buscar usuário");
}

async function carregarUsuario() {
  try {
    const usuario = await buscarUsuario();
    console.log(usuario);
  } catch (erro) {
    console.log("Erro:", erro);
  } finally {
    console.log("Finalizou o processo");
  }
}

carregarUsuario();

• try: trecho principal
• catch: erro
• finally: sempre executa no final

Comparando Promise vs Async/Await

Com .then() e .catch()

buscarDados()
  .then(function (dados) {
    console.log(dados);
  })
  .catch(function (erro) {
    console.log(erro);
  });

Com async/await

async function executar() {
  try {
    const dados = await buscarDados();
    console.log(dados);
  } catch (erro) {
    console.log(erro);
  }
}

A segunda versão costuma ficar mais fácil de ler em fluxos maiores.

Quando usar?

Use async/await quando quiser:

• código mais limpo
• menos encadeamento de .then()
• tratamento de erro organizado com try...catch

Resumo da lição

• async/await é uma forma moderna de consumir Promises.
• await pausa a função assíncrona até a Promise resolver.
• await só pode ser usado dentro de função async.
• try...catch é o padrão para tratar erros com clareza.