Profundidad y límites de la recursión
Comprenda las limitaciones de profundidad de recursión de TypeScript.
Profundidad y límites de la recursión es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de TypeScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de TypeScript Academy incluye 4 lecciones en total.
TypeScript tiene límites de recursión
Los tipos recursivos son potentes, pero el comprobador de tipos limita la profundidad con la que puede instanciarlos. Si alcanza el límite, aparece un error de profundidad.
// Excessively deep recursive types can produce:
// "Type instantiation is excessively deep and possibly infinite."De dónde provienen los errores de profundidad
Los tipos condicionales que recursan sin un caso base claro que se reduzca pueden descontrolarse, especialmente cuando se combinan con uniones grandes o con la construcción 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>;Una recursión acotada segura
Mantenga la recursión superficial y acotada. Construir una tupla pequeña no supone ningún problema; el caso base Acc["length"] extends N la detiene rápidamente.
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);Patrones de tipos recursivos de cola
TypeScript optimiza ciertos tipos condicionales recursivos de cola mediante un acumulador, lo que permite una recursión más profunda que un anidamiento ingenuo.
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 qué ayudan los acumuladores
Pasar los resultados hacia delante en un acumulador mantiene la recursión en posición de cola, que TypeScript puede desenrollar de forma más eficiente que los condicionales profundamente anidados.
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);Evitar la recursión que no es de cola
Envolver la llamada recursiva dentro de otra operación de tipos rompe la posición de cola y puede alcanzar los límites antes. En su lugar, prefiera mantener el estado en un 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");Limitar explícitamente la profundidad
Añada un contador de profundidad para que el tipo se detenga después de un número fijo de niveles, sacrificando completitud a cambio de una terminación garantizada.
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);La profundidad práctica suele ser suficiente
Los tipos recursivos cotidianos, como listas enlazadas, árboles y JSON, nunca alcanzan el límite porque los datos que instancia son superficiales. Los límites afectan principalmente a los cálculos intensivos a nivel de tipos.
type Json = string | number | boolean | null | Json[] | { [k: string]: Json };
const v: Json = { a: { b: { c: 1 } } }; // fine, shallow
console.log(v);Reconocer el mensaje de error
Cuando vea "excessively deep and possibly infinite", busque un caso base ausente, un acumulador en una posición que no sea de cola o una entrada demasiado grande.
// 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");La recursión en tiempo de ejecución es independiente
Estos límites se refieren a la recursión a nivel de tipos. Las funciones recursivas normales que operan sobre tipos recursivos se ejecutan en tiempo de ejecución y solo están limitadas por la pila de llamadas.
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: [] }] }));Diseñar dentro de los límites
Prefiera datos superficiales, patrones recursivos de cola con acumuladores y límites de profundidad explícitos. Con estos hábitos, rara vez alcanzará el límite en código real.
type Length<T extends unknown[]> = T["length"];
type N = Length<[1, 2, 3]>; // 3
const n: N = 3;
console.log(n);Comprobación rápida: límites de recursión
Compruebe su comprensión de la profundidad y los límites de la recursión.
Resumen: profundidad y límites de la recursión
Aprendió que TypeScript limita la profundidad de la recursión a nivel de tipos, que los patrones recursivos de cola con acumuladores y los límites de profundidad explícitos ayudan, y que los datos recursivos cotidianos rara vez alcanzan el límite.
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);Preguntas frecuentes
¿La lección «Profundidad y límites de la recursión» es gratis?
Sí — el texto completo de «Profundidad y límites de la recursión» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de TypeScript Academy, actualiza a CoddyKit PRO. El curso de TypeScript Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Profundidad y límites de la recursión»?
Comprenda las limitaciones de profundidad de recursión de TypeScript. Practicas TypeScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar TypeScript Academy?
No se requiere experiencia previa. TypeScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Profundidad y límites de la recursión»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de TypeScript Academy?
Sí. Cada lección de TypeScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Definiciones de tipos recursivos
- Tipado de estructuras de árbol
- Tipos de valores JSON
- Profundidad y límites de la recursión