PricingLoginStart free
TypeScript Academy · Aula

Tratamento de erros em código TypeScript assíncrono

Gerencie erros assíncronos com wrappers e utilitários tipados

Aula 4 de 413 etapas

Tratamento de erros em código TypeScript assíncrono é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 4 aulas no total.

Boas-vindas

Funções assíncronas tornam o tratamento de erros mais complexo. O TypeScript garante que as rejeições de Promise sejam tratadas corretamente.

Try-catch com async/await

Envolva as chamadas await em try-catch para tratar rejeições de Promise.
async function loadUser(id: number): Promise<User> {
  try {
    return await api.getUser(id);
  } catch (err: unknown) {
    if (err instanceof Error) throw new AppError(err.message);
    throw new AppError('Unknown error');
  }
}

Erros de Promise.all

Promise.all é rejeitada na primeira rejeição. Envolva-a em try-catch.
try {
  const [user, posts] = await Promise.all([getUser(id), getPosts(id)]);
} catch (err) { /* one or both failed */ }

Promise.allSettled

allSettled retorna tanto os sucessos quanto as falhas sem lançar erros.
const results = await Promise.allSettled([getUser(1), getPosts(1)]);
results.forEach(r => {
  if (r.status === 'fulfilled') console.log(r.value);
  else console.error(r.reason);
});

Resultado assíncrono tipado

Combine operações assíncronas com o padrão Resultado para obter um tratamento de erros explícito.
async function safeGet<T>(fn: () => Promise<T>): Promise<Result<T>> {
  try { return { ok: true, value: await fn() }; }
  catch (e) { return { ok: false, error: e as Error }; }
}

Rejeições não tratadas

Escute rejeições não tratadas no Node.js para evitar falhas do processo.
process.on('unhandledRejection', (reason: unknown) => {
  console.error('Unhandled rejection:', reason);
  process.exit(1);
});

Tempo limite com Promise.race

Implemente um padrão de tempo limite tipado com Promise.race.
function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
  const timeout = new Promise<never>((_, reject) =>
    setTimeout(() => reject(new Error('Timeout')), ms));
  return Promise.race([promise, timeout]);
}

Padrão de nova tentativa

Implemente novas tentativas assíncronas tipadas com erros tipados.
async function retry<T>(fn: () => Promise<T>, times: number): Promise<T> {
  for (let i = 0; i < times; i++) {
    try { return await fn(); } catch (e) { if (i === times - 1) throw e; }
  }
  throw new Error('Unreachable');
}

Tratamento de erros concorrentes

Trate erros ao executar operações assíncronas simultâneas.
const [userResult, postsResult] = await Promise.allSettled([
  getUser(id).then(u => ({ ok: true, value: u })).catch(e => ({ ok: false, error: e })),
  getPosts(id).then(p => ({ ok: true, value: p })).catch(e => ({ ok: false, error: e })),
]);

Propagação de erros em AsyncQueue

Os erros em iteradores assíncronos são propagados corretamente com for-await.
async function* generate() {
  yield await fetchA();
  yield await fetchB(); // error here stops the loop
}
for await (const item of generate()) { process(item); }

Middleware de erros tipados no Next.js

Use limites de erros tipados em ações do servidor.
'use server';
async function createUser(data: CreateUserDto): Promise<Result<User>> {
  return safeGet(() => db.user.create({ data }));
}

Verificação rápida

O que acontece se você não capturar uma Promise rejeitada em uma função async/await?
Responda na aula interativa

Recapitulação

Tratamento de erros em código TypeScript assíncrono: você aprendeu os principais conceitos deste tópico e como aplicá-los em projetos reais de TypeScript.
Grátis para começar

Aprenda TypeScript com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
101
Aulas
352
Começar a aprender grátisVer o curso completo

Perguntas Frequentes

A aula “Tratamento de erros em código TypeScript assíncrono” é grátis?

Sim — o texto completo de “Tratamento de erros em código TypeScript assíncrono” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 4 aulas no total.

O que vou aprender em “Tratamento de erros em código TypeScript assíncrono”?

Gerencie erros assíncronos com wrappers e utilitários tipados Você pratica TypeScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar TypeScript Academy?

Nenhuma experiência prévia é necessária. TypeScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Tratamento de erros em código TypeScript assíncrono”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de TypeScript Academy?

Sim. Cada aula de TypeScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Classes e hierarquias de erros tipadas
  2. O padrão Result: Ok e Err
  3. Restringindo erros capturados (unknown versus Error)
  4. Tratamento de erros em código TypeScript assíncrono
← Voltar para TypeScript Academy