TypeScript Academy · Aula

Condicionais no Nível de Tipos

Crie ramificações nos tipos com expressões de tipos condicionais.

Condicionais no Nível de Tipos é 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 condicional em nível de tipos

A linguagem de tipos ganha ramificações com os tipos condicionais. A sintaxe T extends U ? X : Y significa: se T puder ser atribuído a U, o resultado será X; caso contrário, será Y.

Isso equivale, no nível de tipos, a uma expressão if / else.

type IsString<T> = T extends string ? "yes" : "no";

type A = IsString<string>; // "yes"
type B = IsString<number>; // "no"

extends significa atribuível

O teste não verifica igualdade. T extends U é verdadeiro quando um valor do tipo T poderia ser usado onde se espera um U. Tipos literais podem ser atribuídos ao tipo base correspondente.

type T1 = "hello" extends string ? true : false; // true
type T2 = string extends "hello" ? true : false; // false
type T3 = 42 extends number ? true : false;       // true

Escolhendo um tipo de resultado

Os condicionais permitem que um genérico retorne formatos diferentes dependendo da entrada. Aqui, Wrap envolve vetores de forma diferente de valores escalares.

type Wrap<T> = T extends unknown[]
  ? { list: T }
  : { value: T };

type A = Wrap<number>;   // { value: number }
type B = Wrap<string[]>; // { list: string[] }

Filtragem para never

Um truque comum é retornar never em um dos ramos. never significa "nenhum valor" e é útil para remover membros de uniões posteriormente.

type OnlyStrings<T> = T extends string ? T : never;

type A = OnlyStrings<string>; // string
type B = OnlyStrings<number>; // never

Inferência com infer

O verdadeiro poder aparece com a palavra-chave infer. Dentro de um condicional, infer introduz uma nova variável de tipo que captura parte do tipo correspondente.

Aqui, capturamos o tipo de elemento de um vetor.

type ElementType<T> = T extends (infer U)[] ? U : never;

type A = ElementType<number[]>; // number
type B = ElementType<string[]>; // string

Inferência de resultados de funções

Você pode colocar infer em qualquer posição do padrão. Para extrair o tipo de retorno de uma função, faça a inferência da parte depois da seta. É assim que o utilitário integrado ReturnType funciona.

type MyReturn<T> = T extends (...args: any[]) => infer R ? R : never;

type A = MyReturn<() => number>;      // number
type B = MyReturn<(x: string) => boolean>; // boolean

Inferência de várias partes

Um único condicional pode introduzir várias variáveis infer de uma só vez. Aqui, extraímos o primeiro elemento e o restante de uma tupla.

type FirstRest<T> = T extends [infer H, ...infer R]
  ? { head: H; rest: R }
  : never;

type A = FirstRest<[1, 2, 3]>;
// { head: 1; rest: [2, 3] }

Condicionais aninhados

Os condicionais podem ser aninhados, assim como uma sequência de else if. O ramo else de um condicional pode ser outro condicional, formando uma sequência de decisões.

type Describe<T> =
  T extends string ? "text" :
  T extends number ? "num" :
  T extends boolean ? "flag" :
  "other";

type A = Describe<number>; // "num"
type B = Describe<null>;   // "other"

Condições como salvaguardas

Use um condicional para verificar um formato antes de extrair algo dele. Se a entrada não corresponder, recorra a never para que o uso incorreto fique visível.

type GetName<T> = T extends { name: infer N } ? N : never;

type A = GetName<{ name: string }>; // string
type B = GetName<{ age: number }>;  // never

Combinando condições

Você pode exigir várias condições aninhando-as. Aqui, um tipo precisa ser um objeto e ter um id para ser aceito.

type RequireId<T> =
  T extends object
    ? T extends { id: unknown } ? T : never
    : never;

type A = RequireId<{ id: 1; x: 2 }>; // { id: 1; x: 2 }
type B = RequireId<{ x: 2 }>;        // never

Os condicionais estão em toda parte

A maioria dos tipos utilitários integrados é formada internamente por condicionais: NonNullable, Extract, Exclude, Parameters e ReturnType. Entender extends ? : permite compreender todos eles.

type MyNonNullable<T> = T extends null | undefined ? never : T;

type A = MyNonNullable<string | null>; // string

Verificação rápida

Teste sua compreensão dos tipos condicionais e de infer.

Recapitulação

Os tipos condicionais dão à linguagem de tipos uma estrutura se/senão e correspondência de padrões.

T extends U ? X : Y cria ramificações com base na atribuibilidade.
infer captura partes correspondentes em novas variáveis.
Os condicionais podem ser aninhados para formar sequências de decisões.
Retornar never filtra os membros.

A seguir: alimentar um condicional de volta nele mesmo para criar recursão.

Perguntas Frequentes

A aula “Condicionais no Nível de Tipos” é grátis?

Sim — o texto completo de “Condicionais no Nível de Tipos” é 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 “Condicionais no Nível de Tipos”?

Crie ramificações nos tipos com expressões de tipos condicionais. 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 “Condicionais no Nível de Tipos”?

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