Generics en JavaScript: para qué sirven y cómo usarlos en la práctica

Introducción: ¿por qué JavaScript necesita Generics?

El desarrollo en JavaScript (especialmente en el entorno Node.js) a menudo se enfrenta al problema de la duplicación de código. Imagina que necesitas escribir una función que funcione con números, cadenas y arrays. Sin Generics (genéricos), o escribes varias sobrecargas o usas any, perdiendo toda la magia de los tipos.

Generics es un mecanismo que permite crear componentes (funciones, clases, interfaces) que trabajan con diferentes tipos de datos, manteniendo al mismo tiempo un tipado estricto. En el contexto de JavaScript, los genéricos están completamente disponibles a través de TypeScript, pero comprender sus principios es fundamental para cualquier desarrollador moderno.

En este artículo, analizaremos para qué sirven los generics, cómo usarlos en la práctica en Node.js y por qué hacen que tu código sea más seguro y reutilizable.

1. Generics en TypeScript: la base de la seguridad de tipos

Aunque el JavaScript puro no tiene soporte incorporado para genéricos, TypeScript (un superconjunto de JS) los proporciona en su totalidad. Es por eso que todos los frameworks y bibliotecas modernos para Node.js (NestJS, Express con tipos) los utilizan activamente.

Ejemplo simple: la función identity

El ejemplo clásico es una función que devuelve lo que recibe:

// Sin generics — usamos any (perdemos el tipo)function identity(arg: any): any {  return arg;}

// Con generic — el tipo se conservafunction identity<T>(arg: T): T {  return arg;}

// Usoconst num = identity<number>(42);  // Tipo: numberconst str = identity<string>('hola'); // Tipo: string

Observa: <T> es un parámetro de tipo. Le decimos a TypeScript: «El tipo se pasará más tarde». El compilador deduce automáticamente el tipo, por lo que a menudo se puede escribir simplemente identity(42).

¿Por qué es importante para Node.js?

En Node.js, trabajas constantemente con APIs, bases de datos y servicios externos. Los Generics permiten garantizar que los datos lleguen exactamente en el formato que esperas:

// Función para trabajar con APIsasync function fetchData<T>(url: string): Promise<T> {  const response = await fetch(url);  return response.json() as Promise<T>;}

// Ahora conocemos la estructura exacta de la respuestainterface User {  id: number;  name: string;}

const user = await fetchData<User>('/api/user/1');// user.name — cadena, user.id — número (TypeScript lo verifica)

2. Escenarios prácticos: trabajo con arrays y colecciones

Los Generics son especialmente útiles al trabajar con arrays y colecciones de datos. Veamos un ejemplo real de Node.js: una función de filtrado y transformación.

Función genérica para mapeo

// Función que transforma un array de un tipo en un array de otro tipofunction mapArray<T, U>(items: T[], mapper: (item: T) => U): U[] {  return items.map(mapper);}

// Ejemplo: de User obtenemos solo los nombresinterface User {  id: number;  name: string;  email: string;}

const users: User[] = [  { id: 1, name: 'Alice', email: 'alice@example.com' },  { id: 2, name: 'Bob', email: 'bob@example.com' }];

const names: string[] = mapArray(users, (user) => user.name);// names: ['Alice', 'Bob'] — tipo string[] garantizado

Aquí <T, U> son dos parámetros de tipo. T es el tipo del array de entrada, U es el tipo del resultado. Esto proporciona la máxima flexibilidad sin perder los tipos.

Clase genérica para una pila

En Node.js a menudo se necesitan estructuras de datos. Creemos una pila con seguridad de tipos:

class Stack<T> {  private items: T[] = [];

  pu