TypeScript
Uso de keyof, typeof e indexed access types para derivar claves y valores desde estructuras existentes sin duplicar contratos manualmente.
TypeScript puede obtener tipos a partir de otros tipos y de valores conocidos estáticamente.
keyof T → claves conocidas de T
typeof value → tipo estático de un valor
T[K] → tipo de una propiedadtype Product = {
id: string;
name: string;
price: number;
};
type ProductKey = keyof Product;
// "id" | "name" | "price"function readProperty<T, K extends keyof T>(
value: T,
key: K,
): T[K] {
return value[key];
}const price = readProperty(product, "price");
// numberLa relación entre K y el retorno se conserva.
type Scores = {
[playerId: string]: number;
};
type ScoreKey = keyof Scores;
// string | numberJavaScript convierte claves numéricas de objetos a strings, por eso puede aparecer number.
type Value = A | B;
type Keys = keyof Value;Produce las claves seguras presentes en todas las posibilidades, no la unión ingenua de todas las claves específicas.
Para distribuir:
type KeysOfUnion<T> = T extends unknown
? keyof T
: never;const defaultProduct = {
id: "p1",
name: "Keyboard",
price: 100,
};
type Product = typeof defaultProduct;No es el operador runtime dentro de esa posición. TypeScript consulta el tipo estático del binding.
type Result = typeof createProduct();No es válido. Usa:
type Result = ReturnType<typeof createProduct>;const roles = {
admin: "ADMIN",
editor: "EDITOR",
viewer: "VIEWER",
} as const;
type RoleKey = keyof typeof roles;
type Role = (typeof roles)[RoleKey];type ProductId = Product["id"];
// stringtype ProductSummary = Product[
"id" | "name"
];
// stringComo ambas propiedades son string, el resultado es string.
type ProductValue = Product[keyof Product];
// string | numbertype ProductElement = Product[][number];
// ProductCon un valor:
const products = [
{ id: "p1", price: 100 },
{ id: "p2", price: 200 },
] as const;
type ProductItem = (typeof products)[number];type Point = readonly [x: number, y: number];
type Coordinate = Point[number];
// numbertype Description = ProductWithOptional["description"];
// string | undefinedEl acceso refleja la posibilidad de ausencia.
type City = Customer["address"]["city"];Si address puede ser undefined, primero debes excluirlo:
type Address = NonNullable<Customer["address"]>;
type City = Address["city"];const eventHandlers = {
created: handleCreated,
deleted: handleDeleted,
};
type EventName = keyof typeof eventHandlers;El runtime y el tipo comparten una sola fuente.
const key = "price";
type Value = Product[key];No es válido porque key es un valor. Usa:
type Key = typeof key;
type Value = Product[Key];function select<T, K extends keyof T>(
value: T,
keys: readonly K[],
): Pick<T, K> {
return Object.fromEntries(
keys.map((key) => [key, value[key]]),
) as Pick<T, K>;
}La assertion final existe porque la librería estándar no puede demostrar toda la relación dinámica de Object.fromEntries; debe quedar encapsulada y respaldada por la implementación.
(typeof array)[number] obtiene el tipo de elemento.¿Qué diferencia hay entre keyof typeof roles y (typeof roles)[keyof typeof roles]?
El primero obtiene las claves del objeto. El segundo usa esas claves para obtener la unión de sus valores.
Index signatures, Record y claves dinámicas modela diccionarios sin fingir que cualquier clave existe.