TypeScript
Transformación de propiedades mediante mapped types, modificadores y recorridos sobre keyof para derivar contratos nuevos desde tipos existentes.
Un recorre una union de property keys y produce propiedades nuevas.
type ReadonlyVersion<T> = {
readonly [K in keyof T]: T[K];
};type OptionsFlags<T> = {
[K in keyof T]: boolean;
};type Features = {
darkMode(): void;
analytics(): void;
};
type FeatureFlags = OptionsFlags<Features>;Resultado conceptual:
type FeatureFlags = {
darkMode: boolean;
analytics: boolean;
};type StatusMap = {
[K in "idle" | "loading" | "success"]: string;
};Añadir:
type Readonly<T> = {
readonly [K in keyof T]: T[K];
};Eliminar:
type Mutable<T> = {
-readonly [K in keyof T]: T[K];
};Añadir:
type Optional<T> = {
[K in keyof T]?: T[K];
};Eliminar:
type Required<T> = {
[K in keyof T]-?: T[K];
};Un mapped type homomorphic sobre keyof T conserva optional y readonly salvo que los modifiques explícitamente.
type Identity<T> = {
[K in keyof T]: T[K];
};type Nullable<T> = {
[K in keyof T]: T[K] | null;
};type KeysMatching<T, TValue> = {
[K in keyof T]: T[K] extends TValue ? K : never;
}[keyof T];type StringKeys = KeysMatching<Product, string>;El indexed access final convierte el mapa en una union de claves.
type EventHandlers<TEvents> = {
[K in keyof TEvents]: (
event: TEvents[K],
) => void;
};Index signature:
type Values = {
[key: string]: number;
};Mapped type:
type Values = {
[K in "a" | "b"]: number;
};El segundo crea un conjunto cerrado de propiedades.
Mapped types homomorphic pueden preservar la naturaleza de tuple y array.
type PromiseTuple<T extends readonly unknown[]> = {
[K in keyof T]: Promise<T[K]>;
};type DeepReadonly<T> =
T extends (...args: any[]) => any
? T
: T extends readonly unknown[]
? { readonly [K in keyof T]: DeepReadonly<T[K]> }
: T extends object
? { readonly [K in keyof T]: DeepReadonly<T[K]> }
: T;Una definición profunda tiene decisiones de dominio: Date, Map, Set, clases y funciones no siempre deben transformarse igual.
type Getters<T> = {
[K in keyof T as `get${Capitalize<string & K>}`]:
() => T[K];
};Se estudia con template literal types.
type FieldState<T> = {
value: T;
touched: boolean;
error?: string;
};
type FormState<TModel> = {
[K in keyof TModel]: FieldState<TModel[K]>;
};¿Qué función cumple [keyof T] al final de KeysMatching?
Lee todos los valores del mapa temporal y obtiene la union de las claves conservadas, descartando los never.
Conditional types e infer elige tipos según relaciones de assignability y extrae partes internas.