Profundidade e Limites da Recursão
Entenda as restrições de profundidade de recursão do TypeScript.
Profundidade e Limites da Recursão é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 4 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.
TypeScript tem limites de recursão
Tipos recursivos são poderosos, mas o verificador de tipos limita a profundidade com que os instancia. Ao atingir o limite, você recebe um erro de profundidade.
// Excessively deep recursive types can produce:
// "Type instantiation is excessively deep and possibly infinite."De onde vêm os erros de profundidade
Tipos condicionais que recorrem sem um caso-base claro e progressivamente menor podem entrar em espiral, especialmente quando combinados com uniões grandes ou com a construção de tuplas.
type Repeat<N extends number, Acc extends unknown[] = []> =
Acc["length"] extends N ? Acc : Repeat<N, [...Acc, unknown]>;
// Large N can exceed the instantiation depth.
type Five = Repeat<5>;Uma recursão limitada segura
Mantenha a recursão superficial e limitada. Construir uma tupla pequena é aceitável; o caso-base Acc["length"] extends N interrompe a recursão prontamente.
type Tuple<N extends number, Acc extends unknown[] = []> =
Acc["length"] extends N ? Acc : Tuple<N, [...Acc, unknown]>;
type Three = Tuple<3>; // [unknown, unknown, unknown]
const t: Three = [1, 2, 3];
console.log(t.length);Padrões de tipos recursivos em cauda
TypeScript otimiza certos tipos condicionais recursivos em cauda ao transportar um acumulador, permitindo uma recursão mais profunda que o aninhamento ingênuo.
type Reverse<T extends unknown[], Acc extends unknown[] = []> =
T extends [infer Head, ...infer Tail]
? Reverse<Tail, [Head, ...Acc]>
: Acc;
type R = Reverse<[1, 2, 3]>; // [3, 2, 1]
const r: R = [3, 2, 1];
console.log(r);Por que os acumuladores ajudam
Passar os resultados adiante em um acumulador mantém a recursão na posição de cauda, permitindo que TypeScript a desenrole com mais eficiência do que condicionais profundamente aninhados.
type Join<T extends string[], Acc extends string = ""> =
T extends [infer H extends string, ...infer R extends string[]]
? Join<R, Acc extends "" ? H : Acc>
: Acc;
type First = Join<["a", "b", "c"]>; // "a"
const f: First = "a";
console.log(f);Evitando recursão que não é em cauda
Envolver a chamada recursiva em outra operação de tipo rompe a posição de cauda e pode atingir os limites mais cedo. Prefira transportar o estado em um acumulador.
// Non-tail (can be costly): builds nesting around the recursive call
// type Bad<T> = T extends [infer H, ...infer R] ? [H, ...Bad<R>] : [];
// Tail-friendly alternative uses an accumulator parameter.
console.log("prefer accumulators");Limitando a profundidade explicitamente
Adicione um contador de profundidade para que o tipo pare após um número fixo de níveis, trocando completude por terminação garantida.
type Flatten<T, Depth extends unknown[] = []> =
Depth["length"] extends 5
? T
: T extends (infer U)[]
? Flatten<U, [...Depth, unknown]>
: T;
type X = Flatten<number[][]>; // number
const x: X = 7;
console.log(x);A profundidade prática geralmente é suficiente
Tipos recursivos do dia a dia, listas encadeadas, árvores e JSON nunca atingem o limite porque os dados que você instancia são superficiais. Os limites afetam principalmente computações pesadas no nível dos tipos.
type Json = string | number | boolean | null | Json[] | { [k: string]: Json };
const v: Json = { a: { b: { c: 1 } } }; // fine, shallow
console.log(v);Reconhecendo a mensagem de erro
Quando vir "excessively deep and possibly infinite", procure um caso-base ausente, um acumulador em posição que não seja de cauda ou uma entrada grande demais.
// Fixes: add/tighten the base case, switch to tail recursion,
// reduce input size, or cap with a depth counter.
console.log("check base case and tail position");A recursão em tempo de execução é separada
Esses limites dizem respeito à recursão no nível dos tipos. Funções recursivas comuns que operam sobre tipos recursivos são executadas em tempo de execução e limitadas apenas pela pilha de chamadas.
type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function count<T>(n: TreeNode<T>): number {
return 1 + n.children.reduce((a, c) => a + count(c), 0);
}
console.log(count({ value: 1, children: [{ value: 2, children: [] }] }));Projetando dentro dos limites
Prefira dados superficiais, padrões recursivos em cauda com acumuladores e limites de profundidade explícitos. Com esses hábitos, você raramente encontrará o limite em código real.
type Length<T extends unknown[]> = T["length"];
type N = Length<[1, 2, 3]>; // 3
const n: N = 3;
console.log(n);Verificação rápida: limites de recursão
Teste sua compreensão sobre profundidade e limites de recursão.
Recapitulação: profundidade e limites de recursão
Você aprendeu que TypeScript limita a profundidade da recursão no nível dos tipos, que padrões recursivos em cauda com acumuladores e limites de profundidade explícitos ajudam e que dados recursivos comuns raramente atingem o limite.
type Reverse<T extends unknown[], Acc extends unknown[] = []> =
T extends [infer H, ...infer R] ? Reverse<R, [H, ...Acc]> : Acc;
const r: Reverse<[1, 2]> = [2, 1];
console.log(r);Perguntas Frequentes
A aula “Profundidade e Limites da Recursão” é grátis?
Sim — o texto completo de “Profundidade e Limites da Recursão” é 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 “Profundidade e Limites da Recursão”?
Entenda as restrições de profundidade de recursão do TypeScript. 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 4 de 4.
Quanto tempo leva a aula “Profundidade e Limites da Recursão”?
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
- Definições de Tipos Recursivos
- Definindo Tipos de Estruturas em Árvore
- Tipos de Valores JSON
- Profundidade e Limites da Recursão