Cómo evitar operaciones de tipos costosas
Identifique y corrija tipos profundamente recursivos o distributivos.
Cómo evitar operaciones de tipos costosas es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 2 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.
¿Qué hace que una operación de tipos sea costosa?
Los tipos profundamente recursivos, las distribuciones de uniones grandes y las cadenas complejas de infer obligan a TypeScript a instanciar muchas variantes de tipos, lo que provoca ralentizaciones exponenciales.
// Expensive: distributes over every member of a large union
type FilterStrings<T> = T extends string ? T : never;
type Result = FilterStrings<string | number | boolean | null | undefined | ...>;Evite tamaños de unión excesivos
Las uniones con cientos de miembros (por ejemplo, derivadas de muchos literales de cadena) pueden hacer que la comprobación de tipos sea muy lenta. Considere restringir el dominio o utilizar string con validación.
// Expensive
type HugeUnion = "a" | "b" | "c" | /* 200 more ... */ "z";
// Better: string with a runtime check
function isValid(s: string): s is ValidString { return VALID_SET.has(s); }Prefiera interfaces a alias de tipos complejos
TypeScript almacena en caché las interfaces de forma más agresiva que las intersecciones complejas de alias de tipos. Prefiera interface para las formas de objeto a las que se hace referencia muchas veces.
// Slow: recomputed union intersection each time
type BigObject = TypeA & TypeB & TypeC & TypeD;
// Fast: interface (cached)
interface BigObject extends TypeA, TypeB, TypeC, TypeD {}Limite la profundidad de la recursión
Los tipos condicionales recursivos son potentes, pero pueden alcanzar el límite de profundidad de TypeScript (normalmente, 100 niveles). Añada un contador de profundidad para detener la evaluación antes.
type Flatten<T, Depth extends number[] = []> =
Depth["length"] extends 10 ? T
: T extends (infer U)[] ? Flatten<U, [...Depth, 0]>
: T;Almacene en caché los tipos intermedios
Asigne un nombre a los tipos intermedios complejos para que TypeScript pueda almacenarlos en caché y reutilizarlos, en lugar de recalcularlos en cada referencia.
// Before: recomputed at each use
type MyResult<T> = T extends SomeComplex<infer U> ? Transform<U> : never;
// After: split into named intermediates
type ExtractU<T> = T extends SomeComplex<infer U> ? U : never;
type MyResult<T> = Transform<ExtractU<T>>;Evite los tipos mapeados profundos en objetos grandes
Aplicar DeepReadonly a un tipo de objeto muy grande obliga a TypeScript a recorrer cada propiedad de forma recursiva, lo que resulta costoso.
// Expensive on 50-property nested objects
type Safe = DeepReadonly<HugeConfig>;
// Better: annotate at creation time with const assertionsUtilice la evaluación diferida de genéricos
Envolver un tipo costoso en un thunk (un tipo de función que lo devuelve) aplaza la evaluación hasta que el tipo realmente se necesita.
// Lazy evaluation via wrapper
type Lazy<T> = () => T;
type ExpensiveLazy = Lazy<DeepReadonly<HugeConfig>>;Prefiera tipos de retorno explícitos
Anotar explícitamente los tipos de retorno de las funciones evita que TypeScript los infiera repetidamente en cada lugar donde se llama a la función, lo que acelera la comprobación de tipos.
// Let TypeScript infer (may be slow for complex functions)
function process(data: Input) { return transform(data); }
// Faster: explicit annotation
function process(data: Input): Output { return transform(data); }isolatedDeclarations para la comprobación en paralelo
isolatedDeclarations de TypeScript 5.5 o posterior requiere tipos de retorno explícitos y permite comprobar en paralelo los tipos de archivos independientes sin realizar una inferencia completa.
// tsconfig.json
{
"compilerOptions": {
"isolatedDeclarations": true
}
}Referencias de proyecto para el aislamiento
Las referencias de proyecto evitan que TypeScript compruebe los tipos de paquetes que no han cambiado, lo que supone la mayor mejora en monorepos grandes.
# With project references:
# tsc --build only recompiles packages whose sources changed
# Unchanged packages: declaration files used directlyResumen: cómo evitar tipos costosos
Para mantener TypeScript rápido: evite las uniones enormes, almacene en caché los tipos intermedios, prefiera las interfaces a los alias complejos, limite la profundidad de la recursión, utilice tipos de retorno explícitos y aísle los paquetes con referencias de proyecto.
Comprobación rápida
¿Qué enfoque ayuda a TypeScript a almacenar en caché de forma más agresiva la forma de un objeto?
Lo que ha aprendido
Entre las operaciones de tipos costosas de TypeScript se incluyen las uniones grandes, la recursión profunda y la inferencia compleja repetida. Optimice el código almacenando en caché los tipos intermedios, prefiriendo las interfaces, limitando los tamaños de las uniones y utilizando referencias de proyecto para los monorepos.
Preguntas frecuentes
¿La lección «Cómo evitar operaciones de tipos costosas» es gratis?
Sí — el texto completo de «Cómo evitar operaciones de tipos costosas» 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 «Cómo evitar operaciones de tipos costosas»?
Identifique y corrija tipos profundamente recursivos o distributivos. 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 2 de 4.
¿Cuánto tiempo toma la lección «Cómo evitar operaciones de tipos costosas»?
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
- Perfilado de compilaciones lentas de TypeScript
- Cómo evitar operaciones de tipos costosas
- skipLibCheck y declaraciones aisladas
- Comprobación de tipos en CI: estrategias y herramientas