0Pricing
TypeScript Academy · Aula

Tipagem de erros (unknown), redução no catch

Tipifique os parâmetros de catch como unknown e depois faça a redução com instanceof/typeof ou guardas personalizadas para tratar erros com segurança.

Tipagem de erros (unknown), redução no catch é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 2 de 3. 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 3 aulas no total.

Introdução

Objetivo: capturar erros como unknown e restringi-los com segurança. Você usará instanceof, typeof e guardas de tipo personalizadas para ler dados de erros sem surpresas.

unknown + instanceof

Comece com unknown. Restrinja o tipo com instanceof Error para acessar message, stack etc.

async function boom(): Promise<void> { throw new Error("boom") }

async function run() {
  try {
    await boom();
  } catch (e: unknown) {
    if (e instanceof Error) {
      console.error("Handled:", e.message);
    } else {
      console.error("Non-Error thrown:", e);
    }
  }
}

run();

typeof para primitivos

Alguns códigos lançam cadeias de caracteres ou outros valores primitivos. Use typeof para restringir o tipo e tratar a situação adequadamente.

function throwString() { throw "bad" }

try {
  throwString();
} catch (e: unknown) {
  if (typeof e === "string") {
    console.warn("string error:", e.toUpperCase());
  } else {
    console.warn("other error", e);
  }
}

Guarda personalizada

Crie uma guarda de tipo definida pelo usuário para reconhecer estruturas “semelhantes a erros” provenientes de várias camadas.

type ErrorLike = { message: string; code?: string };

function isErrorLike(e: unknown): e is ErrorLike {
  return !!e && typeof e === "object" && "message" in e;
}

try {
  throw { message: "oops", code: "E_BAD" };
} catch (e: unknown) {
  if (isErrorLike(e)) {
    console.error(e.message, e.code ?? "no-code");
  } else {
    console.error("unknown error", e);
  }
}

Registro seguro

Centralize o tratamento de erros. Um pequeno auxiliar restringe o tipo e registra informações com segurança, evitando falhas no próprio registro.

function logErrorSafe(e: unknown): void {
  if (e instanceof Error) {
    console.error("Error:", e.message);
  } else if (typeof e === "string") {
    console.error("Error(string):", e);
  } else {
    try {
      console.error("Error(obj):", JSON.stringify(e));
    } catch {
      console.error("Error(unknown)");
    }
  }
}

try { throw { oops: true } } catch (e: unknown) { logErrorSafe(e) }

Dicas

Dicas:

  • Prefira unknown em catch.
  • Restrinja o tipo com instanceof, typeof ou guardas.
  • Evite presumir que o valor é um Error; códigos de terceiros podem lançar qualquer coisa.

Verificação da tipagem de erros

Verificação rápida: por que preferir unknown em catch?

Recapitulação

Recapitulação: capture como unknown, restrinja o tipo com instanceof/typeof ou guardas personalizadas e centralize o registro seguro.

Perguntas Frequentes

A aula “Tipagem de erros (unknown), redução no catch” é grátis?

Sim — o texto completo de “Tipagem de erros (unknown), redução no catch” é 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 3 aulas no total.

O que vou aprender em “Tipagem de erros (unknown), redução no catch”?

Tipifique os parâmetros de catch como unknown e depois faça a redução com instanceof/typeof ou guardas personalizadas para tratar erros com segurança. 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 2 de 3.

Quanto tempo leva a aula “Tipagem de erros (unknown), redução no catch”?

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. Promise , tipagem de async/await
  2. Tipagem de erros (unknown), redução no catch
  3. Padrões de concorrência (all/settled/race) e tipos
← Voltar para TypeScript Academy