Padrões de inferência profundamente aninhados
Aplique infer recursivamente para extrair tipos complexos
Padrões de inferência profundamente aninhados é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 3 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.
Por que a inferência profunda?
Às vezes, o tipo que você quer está oculto dentro de várias camadas de genéricos. A inferência profunda usa tipos condicionais recursivos ou encadeados para alcançá-lo.
type DeepUnwrap<T> =
T extends Promise<infer U>
? DeepUnwrap<U>
: T;
type A = DeepUnwrap<Promise<Promise<string>>>; // stringTipos condicionais recursivos
O TypeScript 4.1+ oferece suporte a tipos condicionais recursivos, permitindo remover as camadas envolventes uma de cada vez.
type Flatten<T> = T extends Array<infer U> ? Flatten<U> : T;
type B = Flatten<string[][][]>; // stringInferência a partir de genéricos aninhados
Você pode encadear várias variáveis infer em uma única cláusula extends para capturar várias camadas de uma só vez.
type InnerValue<T> =
T extends Map<any, infer V>
? V extends Set<infer S>
? S
: V
: T;
type C = InnerValue<Map<string, Set<number>>>; // numberTipos de propriedades profundas de objetos
Tipos recursivos podem percorrer formatos de objetos para extrair tipos de propriedades profundamente aninhadas.
type DeepGet<T, K extends keyof T> =
T[K] extends object ? T[K] : never;
type Nested = { user: { profile: { name: string } } };
type Profile = DeepGet<Nested, "user">; // { profile: { name: string } }Extração profunda de tipos de elementos de matrizes
Combinar a remoção recursiva de encapsuladores com o tratamento de matrizes abrange qualquer profundidade de aninhamento.
type ElementType<T> = T extends (infer U)[] ? ElementType<U> : T;
type D = ElementType<number[][][]>; // numberRecursão de cauda em tuplas
A manipulação de tuplas com recursão de cauda é um padrão comum para pipelines seguros quanto a tipos e tipos de composição de funções.
type Last<T extends any[]> =
T extends [...infer _, infer L] ? L : never;
type E = Last<[1, 2, 3]>; // 3Limites de profundidade e considerações práticas
O TypeScript limita a profundidade da recursão para evitar laços infinitos. Mantenha a recursão superficial e considere estabelecer um limite com um contador de profundidade quando necessário.
// Deep recursion may hit "Type instantiation is excessively deep"
// Simplify or use branded types to break deep chainsInferência na distribuição de uniões
Quando T é uma união, os tipos condicionais são distribuídos: cada membro é correspondido separadamente e os resultados são combinados em uma união.
type Unwrap<T> = T extends Promise<infer U> ? U : T;
type F = Unwrap<Promise<string> | Promise<number> | boolean>;
// string | number | booleanInferência de tuplas restantes
Padrões de tuplas restantes com infer permitem decomposição em início e fim, além de manipulação variádica de tipos.
type Init<T extends any[]> =
T extends [...infer I, any] ? I : never;
type G = Init<[1, 2, 3, 4]>; // [1, 2, 3]Exemplo do mundo real: resposta de API aninhada
O tipo de uma resposta de API aninhada pode ser desembrulhado até chegar ao tipo de dados usando infer encadeado.
type ApiResponse<T> = { data: T; status: number };
type UnwrapApi<T> = T extends ApiResponse<infer D> ? D : T;
type H = UnwrapApi<ApiResponse<{ users: string[] }>>; // { users: string[] }Recapitulação: inferência profunda
A inferência profunda combina tipos condicionais recursivos, várias variáveis infer e correspondência de padrões estruturais para extrair tipos de estruturas genéricas aninhadas em qualquer profundidade.
Verificação rápida
O que Flatten retorna se Flatten?
O que você aprendeu
A inferência profundamente aninhada usa tipos condicionais recursivos e padrões infer encadeados para alcançar tipos ocultos dentro de vários encapsuladores genéricos. Mantenha a recursão limitada para evitar os limites de profundidade do TypeScript.
Perguntas Frequentes
A aula “Padrões de inferência profundamente aninhados” é grátis?
Sim — o texto completo de “Padrões de inferência profundamente aninhados” é 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 “Padrões de inferência profundamente aninhados”?
Aplique infer recursivamente para extrair tipos complexos 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 3 de 4.
Quanto tempo leva a aula “Padrões de inferência profundamente aninhados”?
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
- Entendendo infer em tipos condicionais
- Construindo ReturnType e Parameters do zero
- Padrões de inferência profundamente aninhados
- Casos práticos de uso de infer: desembrulhando Promises