TypeScript
Uso de conditional types e infer para seleccionar tipos según condiciones, extraer partes de contratos y construir transformaciones reutilizables.
Un elige un tipo según si una relación de assignability se cumple.
type IsString<T> = T extends string
? true
: false;type Result<T> = T extends Constraint
? TrueType
: FalseType;No ejecuta un if runtime.
type MessageOf<T> = T extends {
message: unknown;
}
? T["message"]
: never;type EmailMessage = MessageOf<Email>;Constraint externo:
type MessageOf<T extends { message: unknown }> =
T["message"];Solo acepta tipos con message.
Conditional interno:
type MessageOf<T> = T extends { message: unknown }
? T["message"]
: never;Acepta cualquier T y decide resultado.
infer declara una variable de tipo dentro de la rama verdadera.
type ElementType<T> = T extends readonly (
infer TItem
)[]
? TItem
: never;type ProductItem = ElementType<Product[]>;
// Producttype FunctionReturn<T> =
T extends (...args: any[]) => infer TResult
? TResult
: never;Equivale conceptualmente a ReturnType con decisiones específicas.
type FunctionArguments<T> =
T extends (...args: infer TArgs) => any
? TArgs
: never;type UnwrapPromise<T> =
T extends PromiseLike<infer TValue>
? UnwrapPromise<TValue>
: T;La recursividad modela promesas anidadas. Awaited<T> ya ofrece un contrato estándar más completo.
type Instance<T> =
T extends abstract new (...args: any[]) => infer TInstance
? TInstance
: never;type KeyValue<T> = T extends Map<
infer TKey,
infer TValue
>
? [TKey, TValue]
: never;type ExtractId<T> =
T extends `product:${infer TId}`
? TId
: never;Cuando infieres desde una función con overloads, la extracción suele usar la última firma, normalmente la implementación más general. Conditional types no realizan resolución de overload por cada posibilidad.
type Test = IsString<any>;any puede producir una combinación de ramas y resultados poco intuitivos. Evita diseñar type utilities alrededor de any sin una política clara.
Un conditional distributivo aplicado a never produce never, porque no existen miembros sobre los cuales distribuir.
type IsUnknown<T> = unknown extends T
? ([keyof T] extends [never] ? true : false)
: false;Detectar any, unknown o never con precisión requiere patrones especializados y puede ser innecesario para APIs normales.
Cuando T sigue siendo genérico, TypeScript puede mantener el conditional sin resolver hasta conocer el type argument.
function transform<T>(value: T): T extends string
? string[]
: T[] {
// implementación necesita assertion localizada
}El checker no siempre puede demostrar dentro del cuerpo qué rama corresponde a un T genérico. A menudo overloads o una implementación con retorno amplio son más claras.
type ResponseData<TResponse> =
TResponse extends { data: infer TData }
? TData
: TResponse;¿Qué representa infer TItem dentro de un conditional sobre arrays?
Declara un type variable temporal para el elemento que TypeScript logra extraer cuando T coincide con la forma de array.
Distributividad y control de unions explica cómo conditional types se aplican miembro por miembro.