Tipos genéricos en TypeScript

Los tipos genéricos en TypeScript son una característica poderosa que permite escribir código flexible y reutilizable al trabajar con diferentes tipos de datos de manera abstracta. Aquí te explico en detalle qué son y cómo se utilizan los tipos genéricos:

¿Qué son los tipos genéricos?

Los tipos genéricos permiten definir funciones, clases o interfaces que pueden trabajar con varios tipos de datos de manera flexible y segura. En esencia, te permiten crear componentes que sean independientes del tipo específico sobre el cual están operando.

Sintaxis básica

Los tipos genéricos se definen usando paréntesis angulares `< >` con un nombre de tipo genérico dentro. Por convención, se usa una sola letra (por ejemplo, `T`, `U`, `V`) para representar tipos genéricos, pero puedes usar cualquier nombre válido de identificador.

Ejemplo de función genérica

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

let result = identity<string>("Hello");
console.log(result); // Output: Hello

let result2 = identity<number>(42);
console.log(result2); // Output: 42

En este ejemplo: - `<T>` indica que `identity` es una función genérica que toma un tipo `T`. - `arg: T` significa que el parámetro `arg` puede ser de cualquier tipo `T`. - El tipo de retorno `T` asegura que la función devuelve el mismo tipo que recibe como argumento.

Uso de tipos genéricos en funciones

Los tipos genéricos pueden ser utilizados en varios lugares dentro de una función:

Parámetros múltiples genéricos

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

let p1 = pair(5, "five"); // Infiere tipos: [number, string]
console.log(p1); // Output: [5, "five"]

let p2 = pair(true, 42); // Infiere tipos: [boolean, number]
console.log(p2); // Output: [true, 42]

Restricciones de tipo

Puedes restringir los tipos que puede tomar un tipo genérico usando `extends`:

interface Lengthwise {
  length: number;
}

function loggingIdentity<T extends Lengthwise>(arg: T): T {
  console.log(arg.length); // Sabemos que arg tiene la propiedad .length
  return arg;
}

loggingIdentity({ length: 10, value: 3 }); // Funciona

Uso de tipos genéricos en clases

Los tipos genéricos también pueden ser utilizados en la declaración de clases para hacer que la clase sea genérica sobre uno o más tipos.

class Box<T> {
  private contents: T;

  constructor(value: T) {
    this.contents = value;
  }

  getValue(): T {
    return this.contents;
  }
}

let box1 = new Box<string>("Hello");
console.log(box1.getValue()); // Output: Hello

let box2 = new Box<number>(42);
console.log(box2.getValue()); // Output: 42

Conclusiones sobre tipos genéricos

• Reusabilidad: Los tipos genéricos permiten escribir código que puede manejar múltiples tipos de datos sin repetir lógica.
• Flexibilidad: Proporcionan flexibilidad al permitir que las funciones y las clases se adapten automáticamente a diferentes tipos de datos.
• Seguridad de tipos: Aunque son flexibles, TypeScript aún proporciona chequeos de tipo estáticos para garantizar la seguridad de tipos en tiempo de compilación.

Los tipos genéricos son esenciales para escribir bibliotecas y funciones que puedan ser utilizadas con una amplia gama de tipos de datos, lo que hace que TypeScript sea más robusto y escalable para proyectos grandes y complejos.