Genéricos en TypeScript: escribe la función una vez y úsala con cualquier tipo

Una sola función para listas de precios, nombres o pedidos, sin copiar código y sin recurrir al any

Tienes una función que devuelve el último elemento de una lista de precios. Funciona. Una semana después necesitas lo mismo con una lista de nombres de producto, así que copias la función, cambias number por string y sigues. Luego aparece la lista de pedidos, la de clientes, la de categorías. Cuando quieres darte cuenta tienes cinco funciones idénticas que solo se diferencian en una palabra, y arreglar un fallo en una significa acordarte de arreglarlo en las otras cuatro.

En el post de union types y narrowing viste cómo tipar un dato que puede ser de varias formas. Aquí va el problema contrario: tienes una sola lógica que debe funcionar igual con muchos tipos, y no quieres ni copiarla ni rendirte al any. TypeScript tiene una herramienta para eso que se llama genéricos, y es una de las cosas que más cuesta pillar al principio, sobre todo por la sintaxis de los ángulos y la famosa letra T.

Está escrito pensando en TypeScript 7.0, la versión estable actual (se anunció en julio de 2026). Los ejemplos los he compilado con TypeScript 6.0.3 en modo estricto, y los genéricos llevan muchos años en el lenguaje, así que el código de este post sirve igual en las dos versiones. Si todavía no tienes TypeScript montado, el post de introducción explica la instalación paso a paso.

El problema: la misma función copiada para cada tipo

Vamos con el caso más simple, el de las dos funciones que se pisan. Una devuelve el último precio de una lista y la otra el último nombre:

TypeScript: dos funciones que hacen lo mismo
function ultimoNumero(lista: number[]): number | undefined {
    return lista[lista.length - 1];
}

function ultimoTexto(lista: string[]): string | undefined {
    return lista[lista.length - 1];
}

El cuerpo es idéntico, solo cambia el tipo. Lo primero que se le ocurre a casi todo el mundo (a mí me pasó) es poner any y asunto resuelto, una función para todos:

TypeScript: la salida fácil con any
function ultimoAny(lista: any[]): any {
    return lista[lista.length - 1];
}

const precios = [12.5, 49.9, 8];
const ultimoPrecio = ultimoAny(precios);

console.log(ultimoPrecio.toUpperCase()); // compila sin quejarse

Eso compila sin un solo aviso, aunque ultimoPrecio es un número y los números no tienen toUpperCase. El fallo aparece cuando ejecutas el programa:

Error en tiempo de ejecución
TypeError: ultimoPrecio.toUpperCase is not a function

Justo lo que TypeScript debía evitarte. Con any la función acepta cualquier cosa, pero también devuelve "cualquier cosa", y el compilador pierde el hilo: ya no sabe que de una lista de números sale un número. Necesitamos que el tipo de entrada y el de salida estén conectados.

Una función con un hueco para el tipo

Piensa en una caja de mudanza vacía con una etiqueta en blanco. Cuando metes cosas, escribes en la etiqueta qué hay dentro ("libros", "cocina"), y a partir de ahí cualquiera que la abra sabe lo que va a encontrar. La caja es la misma para todo el mundo; lo que cambia es la etiqueta que rellenas al usarla.

Con una función puedes hacer lo mismo. Escribes la lógica una vez, dejas un hueco con nombre donde iría el tipo, y el hueco se rellena solo cada vez que alguien la llama. A ese hueco se le llama parámetro de tipo, y a esta técnica, genéricos. Se escribe entre ángulos justo después del nombre de la función:

TypeScript: tu primera función genérica
function ultimo<T>(lista: T[]): T | undefined {
    return lista[lista.length - 1];
}

const precios = [12.5, 49.9, 8];
const nombres = ["Camiseta", "Gorra"];

const p = ultimo(precios);  // number | undefined
const n = ultimo(nombres);  // string | undefined

Lee <T> como "esta función tiene un hueco de tipo que se llama T". El T[] del parámetro dice "una lista de lo que sea T", y el T | undefined del resultado dice "devuelvo exactamente eso, o nada". Cuando llamas con precios, TypeScript mira que es una lista de números, rellena T con number y sabe que lo que sale es number | undefined. No tienes que decirle nada: lo deduce solo. A eso se le llama inferencia.

La letra T no tiene nada de especial. Es una costumbre (viene de "Type") y podrías llamarla Elemento o Tipo. En proyectos reales verás T para un solo hueco, y T, U, K, V cuando hay varios. Si el hueco tiene un significado claro, ponle un nombre más descriptivo y nadie se enfadará.

Y ahora, venga, el compilador sí te protege. Si intentas tratar como número lo que sale de la lista de textos:

TypeScript: el compilador recuerda el tipo
const n = ultimo(nombres);
console.log(n?.toFixed(2));
Error del compilador
error TS2551: Property 'toFixed' does not exist on type 'string'. Did you mean 'fixed'?

Con any esto se te habría colado hasta producción. Aquí no pasa de tu editor.

También puedes rellenar el hueco a mano escribiendo el tipo entre ángulos al llamar, así: ultimo<string>(["a", "b"]). Casi nunca hace falta, porque la inferencia acierta. Sirve sobre todo para cazar errores: si dices ultimo<number>(nombres), el compilador te frena con Argument of type 'string[]' is not assignable to parameter of type 'number[]'. Aquí es donde la mayoría se atasca: escribir el tipo explícito en todas las llamadas "por si acaso". Déjalo para cuando la inferencia no llegue.

Cuando T es demasiado libre: restricciones con extends

Un hueco totalmente libre tiene un problema: dentro de la función no sabes nada de T, así que no puedes hacer casi nada con él. Prueba a escribir una función que sume dos valores del mismo tipo:

TypeScript: intentar sumar dos T
function sumar<T>(a: T, b: T): T {
    return a + b;
}
Error del compilador
error TS2365: Operator '+' cannot be applied to types 'T' and 'T'.

Tiene todo el sentido. T podría ser un número, un texto o un objeto, y sumar objetos no significa nada. Esto me costó pillarlo: el error no es que los genéricos "no funcionen", es que le estás pidiendo al compilador que adivine algo que no le has contado.

La solución es poner un límite al hueco con extends: T puede ser cualquier cosa, siempre que cumpla este mínimo. Imagina una tienda donde quieres encontrar el producto más caro, sea una camiseta, una sudadera o lo que sea que venda mañana. Lo único que necesitas saber es que cada producto tiene un precio numérico:

TypeScript: un genérico con restricción
interface ConPrecio {
    precio: number;
}

function masCaro<T extends ConPrecio>(productos: T[]): T | undefined {
    let caro: T | undefined;
    for (const producto of productos) {
        if (!caro || producto.precio > caro.precio) {
            caro = producto;
        }
    }
    return caro;
}

const catalogo = [
    { nombre: "Camiseta", precio: 19.9, talla: "M" },
    { nombre: "Sudadera", precio: 39.95, talla: "L" },
];

const caro = masCaro(catalogo);
console.log(caro?.talla); // L

Fíjate en lo que acaba de pasar. Dentro de la función puedes usar producto.precio porque la restricción garantiza que existe. Pero fuera, el resultado conserva el tipo completo del producto, incluida la talla. Si hubieras escrito la función con ConPrecio a secas (productos: ConPrecio[] y devolver ConPrecio), el resultado habría perdido la talla y el nombre. Ese es el truco de los genéricos con restricción: exigen un mínimo, pero no tiran el resto.

Y si le pasas algo que no cumple el mínimo, el compilador lo dice claro:

TypeScript: un producto sin precio
masCaro([{ nombre: "Camiseta" }]);
Error del compilador
error TS2353: Object literal may only specify known properties, and 'nombre' does not exist in type 'ConPrecio'.

Genéricos en interfaces: una respuesta de API que sirve para todo

Seguro que has escrito una función que pide datos a un servidor, como en el post de la API Fetch. Hoy pides productos, mañana pedidos, pasado clientes. La forma de la respuesta es siempre la misma (los datos, o un error) y lo único que cambia es qué hay dentro de "los datos". Eso es un hueco de tipo en toda regla, y también se puede dejar en una interfaz:

TypeScript: una interfaz genérica y un helper para fetch
interface Respuesta<T> {
    datos: T | null;
    error: string | null;
}

interface Producto {
    id: number;
    nombre: string;
    precio: number;
}

async function pedir<T>(url: string): Promise<Respuesta<T>> {
    try {
        const res = await fetch(url);
        if (!res.ok) {
            return { datos: null, error: `Error ${res.status}` };
        }
        const datos = (await res.json()) as T;
        return { datos, error: null };
    } catch {
        return { datos: null, error: "Sin conexión" };
    }
}

async function cargar(): Promise<void> {
    const r = await pedir<Producto[]>("/api/productos");
    if (r.datos) {
        console.log(r.datos[0].nombre);
    }
}

Aquí sí tienes que escribir el tipo a mano: pedir<Producto[]>. La función no puede deducir qué devolverá tu servidor, porque eso solo lo sabes tú. A cambio, el resto del código ya sabe que r.datos es una lista de productos (o null, que el if descarta) y tu editor te autocompleta nombre y precio.

❌ Error común:

Mira la línea del as T. No comprueba nada: le dices al compilador "confía en mí, esto es un T" y él te cree. Si el servidor cambia el campo precio a texto, TypeScript seguirá tan tranquilo y el fallo llegará en ejecución. Los genéricos organizan los tipos dentro de tu código, pero no validan datos que vienen de fuera. Para eso necesitas comprobar los campos de verdad, como hacías en las validaciones de formularios, o usar una librería de validación.

Ya los estabas usando sin saberlo

Si has llegado hasta aquí con TypeScript, ya has visto genéricos. number[] es en realidad una forma corta de escribir Array<number>, y cuando una función async devuelve Promise<void>, ese void es el hueco rellenado. Los métodos map, filter y reduce de los métodos de Array están tipados con genéricos por dentro, y por eso TypeScript sabe que un map sobre precios que devuelve textos te da una lista de textos.

TypeScript trae además tipos genéricos ya hechos que merece la pena conocer. El más útil para empezar es Partial<T>, que toma un tipo y vuelve opcionales todos sus campos. Sirve para funciones de actualización, donde solo envías lo que cambia:

TypeScript: actualizar solo algunos campos con Partial
function actualizar<T>(original: T, cambios: Partial<T>): T {
    return { ...original, ...cambios };
}

const camiseta: Producto = { id: 1, nombre: "Camiseta", precio: 19.9 };

console.log(actualizar(camiseta, { precio: 24.9 }));
// { id: 1, nombre: 'Camiseta', precio: 24.9 }

Y si te equivocas de tipo en el campo que cambias, salta:

TypeScript: un precio escrito como texto
actualizar(camiseta, { precio: "24,90" });
Error del compilador
error TS2322: Type 'string' is not assignable to type 'number'.

Es el mismo despiste de siempre, el precio con coma que viene de un formulario, pero ahora lo pillas al escribir en vez de al cobrar.

Relacionar dos parámetros con keyof

A veces un hueco depende de otro. Imagina una función que lee un campo de un objeto a partir de su nombre. Quieres que el nombre solo pueda ser uno que exista, y que el resultado tenga el tipo de ese campo. Se hace con dos huecos, y el segundo limitado a los nombres de campo del primero con keyof:

TypeScript: leer un campo con seguridad
function valorDe<T, K extends keyof T>(objeto: T, clave: K): T[K] {
    return objeto[clave];
}

const precioCamiseta = valorDe(camiseta, "precio");
console.log(precioCamiseta.toFixed(2)); // 19.90

keyof T es la unión de todos los nombres de campo de T (aquí, "id" | "nombre" | "precio") y T[K] es "el tipo del campo K dentro de T". Por eso precioCamiseta es un number y no la unión de todos los tipos de campo (string | number). Si escribes mal el nombre del campo, el error aparece al instante:

Error del compilador
error TS2345: Argument of type '"color"' is not assignable to parameter of type 'keyof Producto'.

Es de los patrones que más se ven en código de otras personas, así que conviene reconocerlo aunque no lo escribas a diario.

Una clase genérica: un carrito que acepta cualquier producto

Los genéricos también funcionan en clases. Si hiciste el carrito de la compra con localStorage, tenías una lista de productos y un total. Aquí queda tipado de forma que el carrito puede guardar productos con campos extra, siempre que tengan precio:

TypeScript: una clase Carrito genérica
class Carrito<T extends ConPrecio> {
    private items: T[] = [];

    anadir(item: T): void {
        this.items.push(item);
    }

    total(): number {
        return this.items.reduce((suma, item) => suma + item.precio, 0);
    }

    totalConIva(): number {
        return Math.round(this.total() * 1.21 * 100) / 100;
    }
}

const carrito = new Carrito<Producto>();
carrito.anadir(camiseta);
carrito.anadir({ id: 2, nombre: "Gorra", precio: 12 });

console.log(carrito.total());       // 31.9
console.log(carrito.totalConIva()); // 38.6

El IVA del 21% se multiplica sobre el total y se redondea a céntimos al final, no producto a producto: así evitas que los redondeos intermedios te descuadren la factura. Y como el carrito se creó con Producto, si intentas añadir algo sin precio o con otro tipo de campo, el compilador no te deja. Y si intentas crear un Carrito de algo que ni siquiera tiene precio, ojo, que también salta:

TypeScript: un carrito de algo sin precio
new Carrito<{ nombre: string }>();
Error del compilador
error TS2344: Type '{ nombre: string; }' does not satisfy the constraint 'ConPrecio'.
  Property 'precio' is missing in type '{ nombre: string; }' but required in type 'ConPrecio'.

Cuándo no hace falta un genérico

Con los genéricos pasa lo mismo que con cualquier herramienta nueva: te entran ganas de usarla en todas partes. Mi regla es mirar cuántas veces aparece T en la firma de la función. Si solo aparece una vez, el hueco no conecta nada con nada y puedes quitarlo. Por ejemplo, function imprimir<T>(valor: T): void no necesita T: con unknown o con el tipo concreto que esperas es suficiente y se lee mejor.

Un genérico se justifica cuando relaciona dos cosas: lo que entra con lo que sale (ultimo), o un parámetro con otro (valorDe). Si no hay relación que expresar, el tipo normal basta. Y si empiezas a ver firmas con cuatro huecos y restricciones anidadas, para y pregúntate si de verdad quieres esa función tan flexible; lo normal es que una versión más simple y menos "inteligente" sea la que tu yo del mes que viene agradezca.

Siguiente paso: busca tus funciones gemelas

Abre un proyecto que ya tengas y busca dos funciones que se parezcan tanto que parezcan copiadas, con la misma lógica y solo un tipo distinto. Es más común de lo que crees en cualquier código con listas, filtros y llamadas a una API. Júntalas en una sola con un hueco <T> y comprueba con npx tsc --noEmit que sigue compilando.

Si trabajas con una API, prueba a convertir tus llamadas a fetch en un único pedir<T> como el de arriba. Te quitará bastante código repetido, y te obligará a pensar qué forma tiene cada respuesta, que es justo lo que TypeScript quiere que hagas.

Qué aprender ahora

Has visto que Promise<T> es un genérico, pero seguramente todavía no controlas qué pasa por dentro cuando una función es asíncrona. Ese es el siguiente hueco que conviene rellenar.

Async/Await en JavaScript: adiós callback hell