TypeScript Difícil · Teoría
24 lecciones originales con ejemplos breves, puntos clave y referencias para profundizar.
infer declara una variable de tipo dentro del patrón de un conditional type para extraer retornos, parámetros o elementos.
type Retorno<T> = T extends (...args: never[]) => infer R ? R : never;Un parámetro genérico desnudo a la izquierda de extends distribuye la condición por cada miembro de una unión.
type EnArray<T> = T extends unknown ? T[] : never;
type Resultado = EnArray<string | number>;Un conditional puede referirse a sí mismo para desenvolver estructuras, con límites de instanciación que impiden recursión infinita.
type Profundo<T> = T extends Promise<infer U> ? Profundo<U> : T;Los mapped types pueden filtrar claves, cambiar modificadores y transformar valores según la propiedad recorrida.
type SoloFunciones<T> = { [K in keyof T as T[K] extends Function ? K : never]: T[K] };La cláusula as de un mapped type renombra claves, a menudo con template literals y Capitalize.
type Getters<T> = { [K in keyof T as K extends string ? `get${Capitalize<K>}` : never]: () => T[K] };Los patrones con infer pueden analizar cadenas literales y las utilities intrínsecas cambian mayúsculas de forma eficiente.
type Segmento<T> = T extends `${infer Inicio}/${infer Resto}` ? [Inicio, Resto] : [T, ""];Una API genérica sólida infiere desde argumentos, conserva correlaciones y evita parámetros que sólo aparecen una vez.
function mapear<T, U>(valores: readonly T[], transformar: (valor: T) => U): U[] { return valores.map(transformar); }La varianza describe cómo la compatibilidad entre T y U se traslada a productores y consumidores. strictFunctionTypes evita asignaciones inseguras en parámetros de funciones.
type Productor<out T> = () => T;
type Consumidor<in T> = (valor: T) => void;const ante un parámetro de tipo solicita inferencia literal más específica para argumentos escritos en la llamada.
function tupla<const T extends readonly unknown[]>(valor: T): T { return valor; }Una intersección con una marca única simula distinciones nominales entre valores estructuralmente iguales; una función de validación debe construir la marca.
declare const marcaUsuario: unique symbol;
type UsuarioId = string & { readonly [marcaUsuario]: true };unknown acepta cualquier valor pero exige narrowing; any desactiva comprobaciones y se propaga; never no admite valores alcanzables.
function describir(valor: unknown): string { return typeof valor === "string" ? valor : "otro"; }Los object literals frescos reciben una comprobación adicional de propiedades desconocidas; una variable intermedia puede ser estructuralmente compatible.
type Punto = { x: number; y: number };
const origen: Punto = { x: 0, y: 0 };Los tipos recursivos modelan árboles y listas enlazadas. Los consumidores deben manejar la terminación y evitar expansiones innecesarias.
type Nodo<T> = { valor: T; hijos: readonly Nodo<T>[] };Usa uniones cuando el retorno no cambia por la entrada, overloads para conjuntos discretos y genéricos cuando debes conservar una relación de tipos.
function identidad<T>(valor: T): T { return valor; }Algunas declaraciones con el mismo nombre se fusionan, especialmente interfaces y namespaces. El orden y la clase de declaración determinan si la mezcla es válida.
interface Ventana { titulo: string }
interface Ventana { cerrar(): void }declare module amplía tipos de un módulo existente; el código de runtime que implementa el miembro sigue siendo necesario.
declare module "./observable" { interface Observable<T> { map<U>(f: (valor: T) => U): Observable<U>; } }Un .d.ts describe tipos públicos sin implementación. Debe reflejar con precisión el JavaScript real y seguir la forma global, módulo o plugin del paquete.
export declare function analizar(texto: string): { palabras: number };declare introduce valores o módulos proporcionados por otro entorno. Es un contrato de confianza, no una comprobación de disponibilidad.
declare const VERSION_APLICACION: string;moduleResolution modela cómo el host encuentra archivos y paquetes. node16/nodenext respetan exports; bundler asume capacidades de un bundler y no debe elegirse por ensayo.
{ "compilerOptions": { "module": "NodeNext", "moduleResolution": "NodeNext" } }references divide sistemas grandes en proyectos composite con límites y orden de build explícitos.
{ "files": [], "references": [{ "path": "../core" }, { "path": "../web" }] }allowJs incorpora JavaScript y checkJs aplica análisis; JSDoc puede expresar contratos gradualmente sin renombrar todos los archivos.
// @ts-check
/** @param {number} valor */
export function doble(valor) { return valor * 2; }TypeScript 5.9 soporta la propuesta moderna de decorators con funciones de contexto sin activar experimentalDecorators. TC39 todavía no la ha convertido en estándar final; no incluye parameter decorators ni emitDecoratorMetadata del modelo legacy.
function registrado<T extends new (...args: any[]) => object>(clase: T, contexto: ClassDecoratorContext) { contexto.addInitializer(() => console.log(clase.name)); }
@registrado class Servicio {}Las APIs de tipos necesitan casos que deban compilar y casos marcados con @ts-expect-error. Las igualdades condicionales permiten fijar inferencias sin ejecutar código.
type Igual<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;Tipos públicos legibles, alias intermedios y distribuciones acotadas reducen instanciaciones y mejoran diagnósticos. La máxima precisión no siempre compensa el coste cognitivo o de compilación.
type Identificador<T extends string> = `${T}:${string}`;