TypeScript Genéricos

Los genéricos (Generics) son una característica del lenguaje de programación que permite utilizar marcadores de posición para representar tipos, en lugar de tipos concretos, al definir funciones, clases, interfaces, etc.

Los genéricos son una funcionalidad muy útil al escribir código reutilizable, flexible y con seguridad de tipos.

El propósito principal de usar genéricos es manejar datos de tipos no específicos, permitiendo que el código se aplique a múltiples tipos de datos sin perder la verificación de tipos.

Las ventajas de los genéricos incluyen:

  • Reutilización de código:Se puede escribir código genérico independiente de tipos específicos, mejorando la reutilización del código.

  • Seguridad de tipos:Realiza la verificación de tipos en tiempo de compilación, evitando errores de tipo en tiempo de ejecución.

  • Abstracción:Permite escribir código más abstracto y general, adaptándose a diferentes tipos de datos y estructuras de datos.

Identificadores de genéricos

En los genéricos, normalmente se utilizan algunos identificadores convencionales, como los comunesT(que representa Type),U、Vetc., pero en realidad puedes usar cualquier identificador.

T: representa 'Type', es el nombre de parámetro de tipo genérico más común.

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

K, V: se utiliza para representar los parámetros de tipo genérico de clave (Key) y valor (Value).

interface KeyValuePair<K, V> {
    key: K;
    value: V;
}

E: se utiliza para representar el parámetro de tipo genérico de los elementos de un array.

function printArray<E>(arr: E[]): void {
    arr.forEach(item => console.log(item));
}

R: se utiliza para representar el parámetro de tipo genérico del valor de retorno de una función.

function getResult<R>(value: R): R {
    return value;
}

U, V: normalmente se utiliza para representar el segundo y tercer parámetro de tipo genérico.

function combine<U, V>(first: U, second: V): string {
    return `${first} ${second}`;
}

Estos identificadores son convencionales; en realidad, puedes elegir cualquier nombre que cumpla con las reglas de los identificadores. Lo importante es hacer que el código sea legible y fácil de entender, por lo que se recomienda usar nombres descriptivos en los parámetros de tipo genérico para comprender su propósito.

Funciones genéricas (Generic Functions)

Usa genéricos para crear una función que pueda manejar diferentes tipos:

Ejemplo

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

// Uso de una función genérica
let result = identity<string>("Hello");
console.log(result); // Salida: Hello

let numberResult = identity<number>(42);
console.log(numberResult); // Salida: 42

Análisis:En el ejemplo anterior,identityes una función genérica, que se usa<T>para representar el tipo genérico. Acepta un parámetroargy el valor de retorno son ambos del tipo genéricoT. Al usarla, se puede mediante corchetes angulares<>especificar explícitamente el tipo genérico. La primera llamada especifica elstringtipo, la segunda llamada especifica elnumbertipo.

2. Interfaces genéricas (Generic Interfaces)

Se pueden usar genéricos para definir interfaces, permitiendo que los miembros de la interfaz puedan usar cualquier tipo:

Ejemplo

// Sintaxis básica
interface Pair<T, U> {
    first: T;
    second: U;
}

// Uso de una interfaz genérica
let pair: Pair<string, number> = { first: "hello", second: 42 };
console.log(pair); // Salida: { first: 'hello', second: 42 }

Análisis:Aquí se define una interfaz genéricaPair, que tiene dos parámetros de tipoTyU. Luego, utilizando esta interfaz genérica, se crea un objetopair, en el cualfirstes de tipo cadena (string),secondes de tipo numérico (number).

3. Clases genéricas (Generic Classes)

Los genéricos también se pueden aplicar a variables de instancia y métodos de una clase:

Ejemplo

// Sintaxis básica
class Box<T> {
    private value: T;

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

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

// Uso de una clase genérica
let stringBox = new Box<string>("TypeScript");
console.log(stringBox.getValue()); // Salida: TypeScript

Análisis:En este ejemplo,Boxes una clase genérica, que se usa<T>para representar el tipo genérico. Tanto el constructor como los métodos pueden usar el tipo genéricoT. Al instanciarBox<string>, creamos una instancia que almacena una cadenaBoxinstancia, y a través delgetValuemétodo se obtiene el valor almacenado.

4. Restricciones de genéricos (Generic Constraints)

A veces quieres limitar el rango de tipos de un genérico; puedes usar restricciones de genéricos:

Ejemplo

// Sintaxis básica
interface Lengthwise {
    length: number;
}

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

// Uso correcto
logLength("hello"); // Salida: 5

// Uso incorrecto, porque los números no tienen la propiedad length
logLength(42); // Error

Análisis:En este ejemplo, se define una función genéricalogLength, que acepta unTparámetro de tipo, pero hay una restricción: queTdebe implementarLengthwisela interfaz, que requiere tenerlengthla propiedad. Por lo tanto, se puede llamar correctamente alogLength("hello"), pero no se puede llamar alogLength(42), porque los números no tienenlengthla propiedad.

5. Genéricos y valores predeterminados

Se pueden establecer valores predeterminados para los genéricos, de modo que cuando no se especifica el parámetro de tipo, se pueda usar el tipo predeterminado:

Ejemplo

// Sintaxis básica
function defaultValue<T = string>(arg: T): T {
    return arg;
}

// Uso de una función genérica con valor predeterminado
let result1 = defaultValue("hello"); // Se infiere como tipo string
let result2 = defaultValue(42);      // Se infiere como tipo number

Explicación:Este ejemplo muestra una función genérica con valor predeterminado. La funcióndefaultValueacepta un parámetro genéricoT, y le establece el tipo predeterminado comostring. Al usarla, si no se especifica explícitamente el tipo, se usará el tipo predeterminado. En el ejemplo, en la primera llamadaresult1se infiere comostringtipo, y en la segunda llamadaresult2se infiere comonumbertipo.

Otras extensiones