TypeScript Academy · Aula

O Problema de Lançar Erros

Entenda por que exceções ocultam falhas do sistema de tipos.

O Problema de Lançar Erros é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 1 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.

As exceções são invisíveis

Quando uma função executa throw, a assinatura dela não informa isso. O sistema de tipos não consegue ver quais funções podem falhar, portanto o compilador não incentiva quem faz a chamada a tratar os erros.

Uma função que lança exceções

Esta função parece sempre retornar um número, mas pode lançar uma exceção. O tipo de retorno number oculta completamente o caso de falha.

function parsePort(s: string): number {
  const n = Number(s);
  if (Number.isNaN(n)) throw new Error("bad port");
  return n;
}
console.log(parsePort("8080")); // 8080

Quem faz a chamada se esquece de capturar

Nada obriga quem faz a chamada a envolver a chamada em try/catch. O erro compila sem problemas e só aparece como uma falha durante a execução.

const port = parsePort("oops");
// No compile error; throws at runtime, possibly crashing the app.

try/catch perde o tipo

Mesmo quando você captura a exceção, o valor capturado recebe o tipo unknown (ou any). A estrutura do erro não é rastreada, portanto o tratamento vira uma tentativa.

try {
  parsePort("x");
} catch (e) {
  // e: unknown -> you must narrow it manually
}

Erros como valores

A alternativa é transformar a falha em um valor comum retornado pela função, em vez de uma exceção lançada por ela. Assim, o tipo de retorno mostra honestamente os dois resultados possíveis.

Um esboço que retorna um valor

Em vez de lançar uma exceção, retorne um objeto marcado que descreva o sucesso ou a falha. Quem faz a chamada precisa inspecioná-lo antes de usar o valor.

type ParseResult =
  | { ok: true; value: number }
  | { ok: false; error: string };

Agora o tipo diz a verdade

Uma função que retorna ParseResult informa que pode falhar. Assim, o compilador exige que quem faz a chamada trate o ramo de falha.

function parsePort(s: string): ParseResult {
  const n = Number(s);
  return Number.isNaN(n)
    ? { ok: false, error: "bad port" }
    : { ok: true, value: n };
}

Tratamento obrigatório

Como o valor pode pertencer a qualquer um dos ramos, você não pode ler value sem verificar primeiro ok. O compilador restringe o tipo somente depois dessa verificação.

const r = parsePort("oops");
if (r.ok) console.log(r.value);
else console.log("failed:", r.error);

As exceções ainda têm seu lugar

Falhas realmente inesperadas e irrecuperáveis (erros do programador, falta de memória) ainda podem lançar exceções. Os erros como valores são excelentes para falhas esperadas, como análise e validação.

Explícito em vez de implícito

Retornar erros torna o caminho de falha explícito no tipo, visível no local da chamada e impossível de ignorar acidentalmente, ao contrário de um throw oculto.

Em direção a Resultado e Opção

Essa estrutura marcada de sucesso ou falha se generaliza para um tipo reutilizável de Resultado, enquanto a ausência ou presença se generaliza para Opção; ambos serão abordados a seguir.

Verificação rápida

Faça uma verificação rápida desta lição.

Recapitulação

Erros lançados são invisíveis para os tipos: as assinaturas ocultam as falhas e quem faz as chamadas se esquece de capturá-las. Retornar a falha como um valor explícito (um objeto marcado de sucesso ou erro) torna o caminho de falha visível no tipo e impossível de ignorar, levando aos tipos Resultado e Opção.

Perguntas Frequentes

A aula “O Problema de Lançar Erros” é grátis?

Sim — o texto completo de “O Problema de Lançar Erros” é 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 “O Problema de Lançar Erros”?

Entenda por que exceções ocultam falhas do sistema de tipos. 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 1 de 4.

Quanto tempo leva a aula “O Problema de Lançar Erros”?

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

← Voltar para TypeScript Academy