TypeScript Generics: Guía completa para principiantes

Los generics son una de las características más poderosas de TypeScript, permitiéndote escribir código reutilizable que funciona con múltiples tipos.

¿Qué son los Generics?

Los generics te permiten crear componentes que pueden trabajar con varios tipos en lugar de uno solo, manteniendo la seguridad de tipos.

// Sin generics
function identityNumber(arg: number): number {
  return arg;
}

// Con generics
function identity<T>(arg: T): T {
  return arg;
}

const num = identity<number>(42);
const str = identity<string>("Hola");

Generics en Arrays

function firstElement<T>(arr: T[]): T | undefined {
  return arr[0];
}

const numbers = [1, 2, 3];
const first = firstElement(numbers); // tipo: number | undefined

const words = ["hola", "mundo"];
const firstWord = firstElement(words); // tipo: string | undefined

Constraints (Restricciones)

Puedes limitar qué tipos pueden usarse con un generic:

interface HasLength {
  length: number;
}

function logLength<T extends HasLength>(arg: T): void {
  console.log(arg.length);
}

logLength("hola"); // ✓ OK
logLength([1, 2, 3]); // ✓ OK
logLength(123); // ✗ Error: number no tiene length

Generics en Interfaces

interface ApiResponse<T> {
  data: T;
  status: number;
  message: string;
}

interface User {
  id: number;
  name: string;
}

const userResponse: ApiResponse<User> = {
  data: { id: 1, name: "Roberto" },
  status: 200,
  message: "Success"
};

Múltiples parámetros de tipo

function merge<T, U>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

const result = merge(
  { name: "Roberto" },
  { age: 25 }
);
// result tiene tipo: { name: string } & { age: number }

Generics con Clases

class DataHolder<T> {
  private data: T;
  
  constructor(initialData: T) {
    this.data = initialData;
  }
  
  getData(): T {
    return this.data;
  }
  
  setData(newData: T): void {
    this.data = newData;
  }
}

const stringHolder = new DataHolder<string>("Hola");
const numberHolder = new DataHolder<number>(42);

Conclusión

Los generics son esenciales para escribir código TypeScript robusto y reutilizable. Aunque pueden parecer complejos al principio, con práctica se convierten en una herramienta indispensable.