TypeScript
Uso de constraints y keyof en generics para limitar parámetros de tipo, acceder a propiedades válidas y expresar relaciones seguras entre valores.
Un limita los tipos que puede recibir un generic y permite utilizar capacidades garantizadas por ese límite.
function getLength<T extends { length: number }>(
value: T,
): number {
return value.length;
}function getLength<T>(value: T) {
return value.length;
}TypeScript no sabe que todo T tiene length.
function getIdentifier<T extends { id: string }>(
value: T,
): string {
return value.id;
}Acepta cualquier forma que contenga id: string.
const product = {
id: "p1",
name: "Keyboard",
price: 100,
};
const id = getIdentifier(product);El constraint no convierte el argumento al tipo mínimo; solo exige que lo cumpla.
function getProperty<TObject, TKey extends keyof TObject>(
object: TObject,
key: TKey,
): TObject[TKey] {
return object[key];
}La clave se limita a miembros existentes.
function setProperty<TObject, TKey extends keyof TObject>(
object: TObject,
key: TKey,
value: TObject[TKey],
): void {
object[key] = value;
}La clave y el valor permanecen relacionados.
type Constructor<T> = new (...args: any[]) => T;
function create<T>(ConstructorValue: Constructor<T>): T {
return new ConstructorValue();
}Para evitar any[] en APIs avanzadas:
type Constructor<T, TArgs extends unknown[]> =
new (...args: TArgs) => T;function normalize<T extends string | number>(
value: T,
): string {
return String(value);
}El retorno es string; no necesitas prometer T si transformas el valor.
function addTimestamp<T extends object>(
value: T,
): T & { createdAt: Date } {
return {
...value,
createdAt: new Date(),
};
}object excluye primitivos, pero no garantiza que spread preserve cualquier objeto especial. El constraint estático debe coincidir con la implementación runtime.
function listKeys<T extends Record<PropertyKey, unknown>>(
value: T,
): Array<keyof T> {
return Reflect.ownKeys(value) as Array<keyof T>;
}Usa assertions con cuidado: objetos pueden tener claves no reflejadas exactamente por el tipo estático.
type PropertyKey = string | number | symbol;Es útil para type parameters que representan claves.
function copyProperty<
TSource,
TTarget,
TKey extends keyof TSource & keyof TTarget,
>(
source: TSource,
target: TTarget,
key: TKey,
): void {
target[key] = source[key] as TTarget[TKey];
}La assertion indica que compartir la clave no garantiza automáticamente que ambos valores sean compatibles. Un mejor diseño puede requerir otro constraint.
type CompatibleKeys<TSource, TTarget> = {
[K in keyof TSource & keyof TTarget]:
TSource[K] extends TTarget[K] ? K : never;
}[keyof TSource & keyof TTarget];Los mapped y conditional types pueden expresar claves cuyos valores sí son compatibles.
function example<T extends string>() {}No significa que T sea string exacto ni que se use string cuando no se especifica. Solo limita alternativas.
Un default se declara aparte:
function example<T extends string = string>() {}function merge<T extends object, U extends object>(
first: T,
second: U,
): T & U {
return { ...first, ...second };
}Si existen propiedades iguales con tipos distintos, la firma de intersection puede no reflejar la sobrescritura runtime. El constraint correcto no arregla una relación de retorno incorrecta.
function selectField<
TEntity,
TKey extends keyof TEntity,
>(
entity: TEntity,
key: TKey,
): TEntity[TKey] {
return entity[key];
}extends de generic con herencia de clases.T extends Constraint limita posibilidades.K extends keyof T relaciona claves válidas.T[K] relaciona el valor con la clave.¿Por qué T extends { id: string } no reduce el retorno completo de T a esa forma mínima?
Porque el constraint solo exige una capacidad; T continúa representando el tipo específico inferido, incluidas sus propiedades adicionales.
Inferencia, defaults y const type parameters explica cómo TypeScript decide type arguments y cómo conservar literals.