Generics en JavaScript: para qué sirven y cómo usarlos

Generics en JavaScript: para qué sirven y cómo usarlos

En el mundo del desarrollo moderno con JavaScript y Node.js, el concepto de Generics (genéricos o tipos genéricos) es cada vez más común. Aunque JavaScript nativo no admite tipado estricto, herramientas como TypeScript y JSDoc permiten incorporar potentes mecanismos de programación genérica. En este artículo analizaremos para qué sirven los Generics, cómo funcionan en el contexto de Node.js y cómo usarlos correctamente.

¿Qué son los Generics y para qué sirven?

Los Generics son un mecanismo que permite crear componentes (funciones, clases, interfaces) que trabajan con diferentes tipos de datos, manteniendo al mismo tiempo un tipado estricto. En lugar de escribir la misma función para números, cadenas y arrays, se escribe un único código genérico.

Principales ventajas de los Generics:

• Seguridad de tipos — los errores de tipo se detectan en la fase de compilación/verificación, no en tiempo de ejecución.
• Reutilización de código — una misma función funciona con cualquier tipo de dato.
• Legibilidad — el código se vuelve autodocumentado.
• Integración con IDE — el autocompletado y las sugerencias de tipos funcionan correctamente.

En Node.js, los Generics son especialmente útiles al trabajar con bases de datos, solicitudes API, colecciones de datos y utilidades.

Generics en TypeScript (forma principal)

TypeScript es una extensión de JavaScript que añade tipado estático. Es en TypeScript donde los Generics están implementados de forma más completa. Veamos la sintaxis básica.

Función genérica simple

// Sin Generics — hay que usar anyfunction identity(arg: any): any {    return arg;}

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

// Usoconst num = identity<number>(42);    // tipo numberconst str = identity<string>("hola"); // tipo string

Los corchetes angulares <T> son la declaración del parámetro de tipo. T es un nombre convencional; puede ser cualquier otro (a menudo se usan T, U, V).

Generics con arrays

Uno de los casos más comunes es trabajar con arrays:

// Función que devuelve el primer elemento de un arrayfunction getFirst<T>(arr: T[]): T | undefined {    return arr[0];}

const firstNumber = getFirst([1, 2, 3]);       // numberconst firstString = getFirst(["a", "b", "c"]); // string

Múltiples tipos

Se pueden usar varios parámetros de tipo:

function pair<T, U>(first: T, second: U): [T, U] {    return [first, second];}

const result = pair(42, "respuesta"); // tipo [number, string]

Restricciones (Constraints) en Generics

A veces es necesario limitar qué tipos pueden utilizarse. Para ello se usan restricciones (constraints) con la palabra clave extends.

// Función que solo funciona con objetos que tienen la propiedad lengthfunction getLength<T extends { length: number }>(arg: T): number {    return arg.length;}

getLength("hola");         // 5 — la cadena tiene lengthgetLength([1, 2, 3]);     // 3 — el array tiene length// getLength(42);         // ¡Error! number no tiene length

Esto es especialmente útil en Node.js al trabajar con buffers, cadenas y arrays — todos aquellos que tienen la propiedad length.

Generics en clases e interfaces

Los Generics funcionan muy bien no solo con funciones, sino también con clases e interfaces.

Clase genérica

Ejemplo de una pila simple en Node.js:

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

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

    pop(): T | undefined {        return this.items.pop
```