El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Genéricos

Siguiente ►
►

Los genéricos en TypeScript son una poderosa característica que permite crear componentes reutilizables y flexibles. Los genéricos proporcionan una forma de definir funciones, clases e interfaces que pueden trabajar con diferentes tipos sin perder la tipificación estática.

Conceptos Clave

  1. Definición de Genéricos: Los genéricos permiten que una función, clase o interfaz trabaje con cualquier tipo de dato.
  2. Parámetros Genéricos: Se utilizan para definir el tipo de dato que se va a usar.
  3. Restricciones de Genéricos: Permiten limitar los tipos que se pueden usar con un genérico.

Ejemplos Prácticos

Funciones Genéricas

Las funciones genéricas permiten que una función trabaje con diferentes tipos de datos sin perder la tipificación.

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

// Uso de la función genérica
let output1 = identity<string>("Hola Mundo");
let output2 = identity<number>(100);

Explicación:

  • T es un parámetro genérico que actúa como un marcador de posición para el tipo que se pasará a la función.
  • identity<string>("Hola Mundo") especifica que T es de tipo string.
  • identity<number>(100) especifica que T es de tipo number.

Clases Genéricas

Las clases genéricas permiten que una clase trabaje con diferentes tipos de datos.

class GenericNumber<T> {
    zeroValue: T;
    add: (x: T, y: T) => T;
}

let myGenericNumber = new GenericNumber<number>();
myGenericNumber.zeroValue = 0;
myGenericNumber.add = function(x, y) { return x + y; };

Explicación:

  • GenericNumber<T> es una clase genérica con un parámetro de tipo T.
  • zeroValue y add utilizan el tipo T.
  • myGenericNumber es una instancia de GenericNumber donde T es number.

Interfaces Genéricas

Las interfaces genéricas permiten definir contratos que pueden trabajar con diferentes tipos de datos.

interface Pair<T, U> {
    first: T;
    second: U;
}

let pair: Pair<string, number> = { first: "uno", second: 1 };

Explicación:

  • Pair<T, U> es una interfaz genérica con dos parámetros de tipo T y U.
  • pair es una instancia de Pair donde T es string y U es number.

Restricciones de Genéricos

Las restricciones permiten limitar los tipos que se pueden usar con un genérico.

interface Lengthwise {
    length: number;
}

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

// Uso de la función con restricción
loggingIdentity({ length: 10, value: 3 });

Explicación:

  • T extends Lengthwise indica que T debe tener una propiedad length.
  • loggingIdentity puede aceptar cualquier tipo que tenga una propiedad length.

Ejercicios Prácticos

Ejercicio 1: Función Genérica

Crea una función genérica reverseArray que tome un array de cualquier tipo y devuelva un nuevo array con los elementos en orden inverso.

function reverseArray<T>(items: T[]): T[] {
    return items.reverse();
}

// Prueba la función
let reversedNumbers = reverseArray<number>([1, 2, 3, 4]);
console.log(reversedNumbers); // [4, 3, 2, 1]

let reversedStrings = reverseArray<string>(["a", "b", "c"]);
console.log(reversedStrings); // ["c", "b", "a"]

Ejercicio 2: Clase Genérica

Crea una clase genérica Stack que implemente una pila (stack) con operaciones push, pop y peek.

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

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

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

    peek(): T | undefined {
        return this.items[this.items.length - 1];
    }
}

// Prueba la clase
let numberStack = new Stack<number>();
numberStack.push(10);
numberStack.push(20);
console.log(numberStack.peek()); // 20
console.log(numberStack.pop());  // 20
console.log(numberStack.pop());  // 10

Resumen

En esta sección, hemos aprendido sobre los genéricos en TypeScript, una característica que permite crear componentes reutilizables y flexibles. Hemos cubierto:

  • La definición y uso de funciones, clases e interfaces genéricas.
  • Cómo aplicar restricciones a los genéricos para limitar los tipos permitidos.
  • Ejemplos prácticos y ejercicios para reforzar los conceptos.

En el siguiente tema, exploraremos los alias de tipos, una herramienta útil para simplificar y mejorar la legibilidad del código.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados