TypeScript
Modelado de diccionarios y claves dinámicas con index signatures y Record, incluyendo restricciones, acceso seguro y diferencias con propiedades conocidas.
Una index signature describe objetos con claves no conocidas individualmente, pero cuyos valores siguen un contrato común.
type Inventory = {
[productId: string]: number;
};type Scores = {
[playerId: string]: number;
};const scores: Scores = {
playerA: 10,
playerB: 20,
};type Scores = {
total: number;
[playerId: string]: number;
};total también debe ser compatible con number.
type Inventory = {
total: number;
quantities: Record<string, number>;
};Evita obligar a que todas las propiedades tengan el mismo tipo.
type Scores = Record<string, number>;Es un mapped type equivalente en muchos casos a una index signature string.
type Permission =
| "products.read"
| "products.write"
| "orders.read";
type Permissions = Record<Permission, boolean>;Ahora deben existir todas las claves de la union.
type OptionalPermissions = Partial<
Record<Permission, boolean>
>;Las claves pueden faltar.
const score = scores[playerId];Sin el flag puede verse como number aunque la clave no exista.
Con noUncheckedIndexedAccess:
number | undefinedRefleja mejor el runtime.
settings.unknownKey;Con este flag, miembros que provienen únicamente de index signature deben accederse con corchetes:
settings["unknownKey"];Hace visible que la propiedad no es un miembro declarado.
type NumericDictionary = {
[index: number]: string;
};Útil para estructuras indexadas numéricamente, aunque arrays y tuples suelen expresar mejor secuencias.
type SymbolRegistry = {
[key: symbol]: Metadata;
};type DataAttributes = {
[key: `data-${string}`]: string | undefined;
};Restringe la forma de claves abiertas.
type Options = {
width?: number;
height?: number;
[key: `data-${string}`]: unknown;
};Permite extensiones con prefijo sin aceptar cualquier typo ordinario.
Record<string, T> representa un objeto y hereda reglas de property keys, prototipo y serialización.
Map<K, V>:
Elige según el runtime, no solo por el tipo.
Para un diccionario sin prototipo:
const dictionary: Record<string, number> = Object.create(null);El tipo no comunica por sí solo que el prototipo es null; el valor runtime sí cambia.
for (const key of Object.keys(scores)) {
const value = scores[key];
}Con noUncheckedIndexedAccess, value incluye undefined. La clave proviene del objeto, pero este tipo general no demuestra presencia a nivel estático.
Una index signature acepta claves adicionales por diseño. No la uses para evitar excess property checking en objetos con un conjunto conocido.
Peligroso:
type Product = {
id: string;
[key: string]: unknown;
};Oculta typos y vuelve cada acceso más amplio.
type EventMap = {
"product.created": ProductCreated;
"product.deleted": ProductDeleted;
};
type Handlers = {
[K in keyof EventMap]?: (
event: EventMap[K],
) => void;
};Un mapped type mantiene la relación entre cada clave y su payload.
[key: string]: any para silenciar errores.¿Por qué Record<string, Product> no garantiza que products["missing"] exista en runtime?
Porque el tipo describe el valor esperado para claves presentes, pero un objeto normal puede no tener una clave arbitraria. noUncheckedIndexedAccess hace visible esa ausencia.
Branded y opaque types añade identidad estática a valores estructuralmente iguales.