TypeScript Academy · Aula

Modelando Tipos Result

Represente sucesso e falha como dados com Result.

Modelando Tipos Result é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 2 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.

O tipo Resultado

Um Resultado representa uma operação que tem sucesso com um valor ou falha com um erro, como uma união discriminada que pode ser retornada em vez de lançar uma exceção.

Definindo Resultado

A estrutura clássica usa o discriminante ok. Quando ok é verdadeiro, existe um value; quando é falso, existe um error.

type Result<T, E> =
  | { ok: true; value: T }
  | { ok: false; error: E };

Funções auxiliares de construção

As pequenas funções auxiliares ok e err tornam a criação de resultados concisa e legível, em vez de exigir que os literais de objeto sejam escritos manualmente todas as vezes.

const ok = <T>(value: T): Result<T, never> => ({ ok: true, value });
const err = <E>(error: E): Result<never, E> => ({ ok: false, error });

Retornando um Resultado

Uma função que pode falhar retorna ok(value) ou err(error). O tipo de retorno informa essas duas possibilidades a quem fizer a chamada.

function divide(a: number, b: number): Result<number, string> {
  return b === 0 ? err("divide by zero") : ok(a / b);
}

Restringindo com ok

Verificar result.ok restringe a união. Dentro do ramo verdadeiro, o TypeScript sabe que value existe; dentro do ramo falso, sabe que error existe.

const r = divide(10, 2);
if (r.ok) console.log(r.value); // 5
else console.log(r.error);

O discriminante conduz à segurança

O campo ok é o discriminante que permite ao compilador escolher o ramo correto. Você não pode acessar value sem provar primeiro que ok é verdadeiro.

const r = divide(1, 0);
// r.value here is a type error until we check r.ok
if (!r.ok) console.log("err:", r.error);

Erros tipados

Os erros podem ser mais ricos do que simples textos. Usar uma união de erros tipados permite que quem faz a chamada trate cada tipo com precisão depois da restrição.

type DivErr = { kind: "zero" } | { kind: "overflow" };
function div(a: number, b: number): Result<number, DivErr> {
  if (b === 0) return err({ kind: "zero" });
  return ok(a / b);
}

Tratamento exaustivo de erros

Como o tipo de erro é uma união, um switch sobre o discriminante pode ser verificado quanto à exaustividade, garantindo que todo modo de falha seja tratado.

const r = div(1, 0);
if (!r.ok) {
  switch (r.error.kind) {
    case "zero": console.log("no zero"); break;
    case "overflow": console.log("too big"); break;
  }
}

Uma função auxiliar para valor alternativo

Às vezes, você só quer o valor ou uma alternativa. Uma pequena função unwrapOr torna o código claro e mantém o tratamento da falha no local apropriado.

function unwrapOr<T, E>(r: Result<T, E>, fallback: T): T {
  return r.ok ? r.value : fallback;
}
console.log(unwrapOr(divide(1, 0), -1)); // -1

Resultado versus lançamento de exceções

Result move a falha para o tipo de retorno, portanto quem faz a chamada precisa lidar com ela. A desvantagem é um código mais explícito, que geralmente vale a pena para erros esperados.

Um exemplo completo

Reunindo tudo: defina funções auxiliares, retorne resultados e restrinja o tipo antes de usar o valor. O compilador garante que o ramo de erro seja considerado.

function safeParse(s: string): Result<number, string> {
  const n = Number(s);
  return Number.isNaN(n) ? err("NaN") : ok(n);
}
const p = safeParse("42");
console.log(p.ok ? p.value : p.error); // 42

Verificação rápida

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

Recapitulação

Resultado<T, E> é uma união discriminada { ok: true; value } ou { ok: false; error }. Crie-a com as funções auxiliares ok/err e restrinja-a por meio de ok para acessar value ou error com segurança; os erros tipados permitem um tratamento exaustivo.

Perguntas Frequentes

A aula “Modelando Tipos Result” é grátis?

Sim — o texto completo de “Modelando Tipos Result” é 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 “Modelando Tipos Result”?

Represente sucesso e falha como dados com Result. 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 4.

Quanto tempo leva a aula “Modelando Tipos Result”?

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