TypeScript
Fundamentos de generics para conservar relaciones entre entradas y salidas, reutilizar contratos y evitar tipos amplios que pierden información.
Un permite describir una relación entre tipos sin decidir de antemano cuál será el tipo concreto.
function identity<T>(value: T): T {
return value;
}Sin generic:
function identity(value: unknown): unknown {
return value;
}El valor retornado pierde información.
const result = identity("hello");
// unknownCon generic:
const result = identity("hello");
// "hello"La relación se conserva.
function identity<T>(value: T): T {
return value;
}T es un parámetro de tipo.value es un parámetro runtime.identity(10);
// T = number
identity({ id: "p1" });
// T = { id: string }Normalmente el compilador infiere el tipo. Especificarlo manualmente puede ser útil cuando la entrada no aporta suficiente información.
identity<string>("hello");function createPair<TFirst, TSecond>(
first: TFirst,
second: TSecond,
): [TFirst, TSecond] {
return [first, second];
}const pair = createPair("stock", 10);
// [string, number]Los nombres descriptivos son mejores que T, U, V cuando el rol no es obvio.
function first<T>(
values: readonly T[],
): T | undefined {
return values[0];
}first([1, 2, 3]);
// number | undefinedfunction getProperty<TObject, TKey extends keyof TObject>(
object: TObject,
key: TKey,
): TObject[TKey] {
return object[key];
}El retorno depende de la clave concreta.
Innecesario:
function print<T>(value: T): void {
console.log(value);
}El generic no relaciona nada útil. unknown expresa mejor que acepta cualquier valor:
function print(value: unknown): void {
console.log(value);
}Un type parameter debería aparecer al menos dos veces o participar en una transformación significativa.
function wrap<T>(value: T): { value: T } {
return { value };
}Aunque aparece en entrada y salida, sí conserva información.
Union:
function reverse(value: string | number[]): string | number[];La relación entre entrada y retorno puede perderse.
Generic limitado:
function echo<T extends string | number[]>(value: T): T {
return value;
}Conserva el tipo exacto, aunque la implementación debe retornar realmente el mismo tipo.
type ApiResponse<TData> = {
data: TData;
requestId: string;
};type ProductResponse = ApiResponse<Product>;interface Repository<TEntity> {
findById(id: string): Promise<TEntity | undefined>;
save(entity: TEntity): Promise<void>;
}class Box<T> {
constructor(private value: T) {}
get(): T {
return this.value;
}
}El generic existe sobre el lado de instancia. Miembros static no pueden usar directamente el type parameter de la instancia.
const empty = [];Puede inferirse como any[] o never[] según contexto y evolución.
const products: Product[] = [];En una factory:
const response = createResponse<Product[]>([]);El type argument comunica la intención que el valor vacío no puede aportar.
async function request<T>(
parse: (value: unknown) => T,
): Promise<T> {
const rawValue: unknown = await response.json();
return parse(rawValue);
}El generic relaciona el parser con el resultado. No reemplaza validación.
function clone<T extends object>(value: T): T {
return { ...value };
}La firma promete devolver T, pero spread es superficial y puede no preservar prototipo, non-enumerables o clases. La relación de tipos no demuestra equivalencia runtime.
Peligroso:
function parse<T>(value: string): T {
return JSON.parse(value);
}T lo decide el consumidor, pero la implementación no valida. Es una assertion disfrazada.
Mejor:
function parse<T>(
value: string,
parser: (rawValue: unknown) => T,
): T {
return parser(JSON.parse(value));
}type Page<TItem> = {
items: TItem[];
page: number;
totalPages: number;
};
async function loadPage<TItem>(
url: URL,
parseItem: (value: unknown) => TItem,
): Promise<Page<TItem>> {
const value: unknown = await requestJson(url);
return parsePage(value, parseItem);
}unknown basta.unknown es mejor cuando no existe una relación.¿Por qué function parse<T>(text: string): T es una API peligrosa?
Porque el consumidor elige T sin que la implementación compruebe que el JSON tenga esa forma. El generic finge una garantía que el runtime no demuestra.
Constraints y keyof en generics restringe qué operaciones puede realizar una abstracción genérica.