TypeScript Assincronia Intermediário

Código assíncrono tipado

Em TypeScript, o código assíncrono é totalmente tipado: uma função async sempre retorna uma Promise<T>, e você pode anotar explicitamente esse tipo. A palavra-chave await pausa a execução até a promise resolver e devolve o valor já com o tipo T, sem precisar de .then(). O utilitário de tipo Awaited<T> extrai o tipo resolvido de uma promise — útil para criar funções genéricas que aceitam promises ou valores comuns. Erros também podem ser tipados: em vez de any no catch, você pode criar classes de erro e usar type guards para tratá-los com segurança.

Pontos-chave

Toda função async retorna Promise<T>; o tipo de retorno pode ser anotado ou inferido.
await desembrulha a promise e entrega o valor com o tipo T.
Awaited<T> obtém o tipo resolvido de uma promise, útil em funções genéricas.
Erros em try/catch são unknown por padrão; use type guards ou classes de erro para tipá-los.
Evite any em blocos catch; prefira unknown e verificação com instanceof.

async_typed.ts

// Exemplo: funções assíncronas tipadas e erros personalizados

class ValidationError extends Error {
  constructor(message: string) {
    super(message);
    this.name = "ValidationError";
  }
}

interface User {
  id: number;
  name: string;
}

// Função assíncrona que simula buscar um usuário
async function fetchUser(id: number): Promise<User> {
  if (id <= 0) {
    throw new ValidationError("ID deve ser positivo");
  }
  // Simula latência
  await new Promise((resolve) => setTimeout(resolve, 100));
  return { id, name: `Usuário ${id}` };
}

// Função genérica que aceita valor ou Promise<valor> e retorna o valor resolvido
async function resolveValue<T>(value: T | Promise<T>): Promise<Awaited<T>> {
  return await value;
}

async function main(): Promise<void> {
  try {
    const user = await fetchUser(42);
    console.log(user.name); // Usuário 42

    const resolved = await resolveValue(Promise.resolve(10));
    console.log(resolved); // 10

    await fetchUser(-1); // lança ValidationError
  } catch (error: unknown) {
    if (error instanceof ValidationError) {
      console.error("Erro de validação:", error.message);
    } else {
      console.error("Erro inesperado:", error);
    }
  }
}

main();

Código assíncrono tipado

Pontos-chave

Exercícios

Função async simples com tipo explícito

Tratamento de erros tipados com classe personalizada

Função genérica com Awaited e tratamento de erros tipados

Continue estudando