Dominando
Async em JavaScript

copiarconsole.log("1");
console.log("2");
console.log("3");
// 1, 2, 3

copiarconsole.log("Início");

setTimeout(() => {
  console.log("Demorou...");
}, 2000);

console.log("Fim");

Início
Fim
Demorou...   ← aparece depois de 2 segundos

copiarconst minhaPromise = new Promise((resolve, reject) => {
  // tarefa assíncrona aqui
  // resolve(valor)  → sucesso
  // reject(erro)    → falha
});

copiarconst promessa = new Promise((resolve, reject) => {
  const sucesso = true;

  if (sucesso) {
    resolve("Deu certo! ✔");
  } else {
    reject("Deu erro! ✘");
  }
});

copiarpromessa
  .then(res => console.log(res))   // "Deu certo! ✔"
  .catch(err => console.log(err)); // caso rejeite

copiarfunction buscarUsuario() {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve({ nome: "Igor", idade: 25 });
    }, 2000);
  });
}

buscarUsuario().then(usuario => {
  console.log(usuario);
  // { nome: "Igor", idade: 25 }
});

copiarminhaPromise
  .then(resultado => {
    console.log("Sucesso:", resultado);
  })
  .catch(erro => {
    console.log("Erro:", erro);
  })
  .finally(() => {
    console.log("Sempre executa!");
  });

copiar// ❌ difícil de ler e manter
fazerA(() => {
  fazerB(() => {
    fazerC(() => {
      fazerD(() => {
        console.log("fim"); // pirâmide da morte
      });
    });
  });
});

copiar// ✅ linear e legível
fetchDados()
  .then(dados => processar(dados))
  .then(result => salvar(result))
  .then(final => console.log(final))
  .catch(err => console.log("Erro:", err));

copiarfunction dobrar(n) {
  return Promise.resolve(n * 2);
}

Promise.resolve(5)
  .then(dobrar)   // 10
  .then(dobrar)   // 20
  .then(dobrar)   // 40
  .then(v => console.log(v)); // 40

copiarasync function minhaFuncao() {
  return "Olá";
}

// equivale a:
function minhaFuncao() {
  return Promise.resolve("Olá");
}

copiarasync function executar() {
  const resultado = await Promise.resolve("Deu certo!");
  console.log(resultado); // "Deu certo!"
}

executar();

copiarfunction esperar(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function processo() {
  console.log("Início");

  await esperar(2000);
  console.log("Depois de 2s");

  await esperar(1000);
  console.log("Depois de mais 1s");

  console.log("Fim");
}

processo();

Início
Depois de 2s     ← após 2 segundos
Depois de mais 1s ← após mais 1 segundo
Fim

copiarasync function buscar() {
  try {
    const resposta = await fetch("https://api.exemplo.com/dados");
    const dados = await resposta.json();
    console.log(dados);
  } catch (erro) {
    console.log("Erro:", erro);
  } finally {
    console.log("Requisição finalizada.");
  }
}

copiarconst p1 = Promise.resolve(1);
const p2 = Promise.resolve(2);
const p3 = Promise.resolve(3);

Promise.all([p1, p2, p3]).then(res => {
  console.log(res); // [1, 2, 3]
});

copiarasync function executar() {
  const [user, posts, comments] = await Promise.all([
    fetchUser(),
    fetchPosts(),
    fetchComments()
  ]);

  console.log(user, posts, comments);
}

copiarPromise.race([
  new Promise(r => setTimeout(() => r("A"), 1000)),
  new Promise(r => setTimeout(() => r("B"), 500))
]).then(console.log);

// "B"  (terminou primeiro)

copiarPromise.allSettled([
  Promise.resolve("ok"),
  Promise.reject("erro"),
  Promise.resolve("ok também")
]).then(console.log);

// [
//   { status: "fulfilled", value: "ok" },
//   { status: "rejected",  reason: "erro" },
//   { status: "fulfilled", value: "ok também" }
// ]

copiar// ❌ esqueceu o await — dados é uma Promise, não o resultado!
const dados = fetchDados();
console.log(dados); // Promise { <pending> }

// ❌ sem tratamento de erro
async function f() {
  const dados = await fetchDados(); // pode explodir silenciosamente
}

// ❌ await em série desnecessário (lento!)
const user  = await fetchUser();   // espera 1s
const posts = await fetchPosts();  // espera mais 1s
// total: 2s! Use Promise.all (seria 1s)

copiar// ✅ sempre await quando precisar do valor
const dados = await fetchDados();

// ✅ sempre try/catch
try {
  const dados = await fetchDados();
} catch (err) {
  console.log(err);
}

// ✅ Promise.all para operações independentes
const [user, posts] = await Promise.all([
  fetchUser(),
  fetchPosts()
]);

copiar// Simula requisições assíncronas
function buscarUsuario() {
  return new Promise(resolve => {
    setTimeout(() => resolve({ id: 1, nome: "Igor" }), 1500);
  });
}

function buscarPosts(userId) {
  return new Promise(resolve => {
    setTimeout(() => resolve(["Post 1", "Post 2"]), 1000);
  });
}

// Função principal
async function main() {
  try {
    console.log("Buscando dados...");

    // Busca usuário e posts em paralelo!
    const [usuario, posts] = await Promise.all([
      buscarUsuario(),
      buscarPosts(1)
    ]);

    console.log("Usuário:", usuario.nome);
    console.log("Posts:", posts);

  } catch (err) {
    console.log("Erro:", err);
  } finally {
    console.log("Finalizado!");
  }
}

main();

Buscando dados...
Usuário: Igor          ← após ~1.5s (paralelo, não 2.5s!)
Posts: ["Post 1", "Post 2"]
Finalizado!

// Promise     → objeto que resolve no futuro
// then/catch  → forma "clássica" de consumir
// async       → função que retorna Promise
// await       → pausa e aguarda a Promise
// try/catch   → trata erros com async/await
// Promise.all → paralelo — mais rápido!
// Promise.race → vence o primeiro
// allSettled  → retorna todos, com status