Colas de tareas en TypeScript: guía completa para principiantes

Introducción a las colas de tareas en TypeScript

La cola de tareas (Queue) es una de las estructuras de datos fundamentales en programación, que funciona bajo el principio FIFO (First In, First Out — «primero en entrar, primero en salir»). Imagine una cola normal en una tienda: el primer cliente que se pone en la cola es atendido primero. En programación, la cola de tareas se utiliza en todas partes: desde el procesamiento de solicitudes en el servidor hasta la gestión de operaciones asíncronas en el navegador.

En este artículo, analizaremos cómo crear y usar una cola de tareas en TypeScript. Aprenderá a tipificar la cola, implementar los métodos principales y aplicarla en proyectos reales. El material está dirigido a desarrolladores principiantes familiarizados con los fundamentos de TypeScript.

Operaciones básicas con la cola

Cualquier cola de tareas debe soportar varias operaciones básicas:

• enqueue (agregar un elemento al final de la cola);
• dequeue (extraer un elemento del inicio de la cola);
• peek (ver el primer elemento sin eliminarlo);
• isEmpty (verificar si la cola está vacía);
• size (conocer la cantidad de elementos).

En TypeScript, podemos implementar una cola basada en un array o en una lista enlazada. Para simplificar, comenzaremos con un array.

Implementación de cola basada en array

Crearemos una clase Queue usando genéricos — esto permitirá almacenar datos de cualquier tipo:

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

    // Agregar un elemento al final de la cola    enqueue(element: T): void {        this.items.push(element);    }

    // Eliminar y devolver el primer elemento    dequeue(): T | undefined {        return this.items.shift();    }

    // Ver el primer elemento sin eliminarlo    peek(): T | undefined {        return this.items[0];    }

    // Verificar si la cola está vacía    isEmpty(): boolean {        return this.items.length === 0;    }

    // Obtener el tamaño de la cola    size(): number {        return this.items.length;    }}

Ahora podemos crear una cola para cualquier tipo de dato:

// Cola de stringsconst stringQueue = new Queue<string>();stringQueue.enqueue('Tarea 1');stringQueue.enqueue('Tarea 2');console.log(stringQueue.dequeue()); // 'Tarea 1'

// Cola de númerosconst numberQueue = new Queue<number>();numberQueue.enqueue(10);numberQueue.enqueue(20);console.log(numberQueue.peek()); // 10

Desventajas de la implementación con array

El método shift() en JavaScript/TypeScript tiene una complejidad de O(n), ya que después de eliminar el primer elemento, todos los demás se desplazan. Para grandes volúmenes de datos, esto no es eficiente. La solución es implementar una cola basada en un objeto o en una lista enlazada.

Cola optimizada con objeto

Para evitar el desplazamiento de elementos, almacenaremos los elementos en un objeto y rastrearemos los índices de inicio y fin:

class OptimizedQueue<T> {    private items: Record<number, T> = {};    private head: number = 0;    private tail: number = 0;

    enqueue(element: T): void {        this.items[this.tail] = element;        this.tail++;    }

    dequeue(): T | undefined {        if (this.isEmpty()) {            return undefined;        }        const item = this.items[this.head];        delete this.items[this.head];        this.head++;        return item;    }

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

    isEmpty(): boolean {        return this.tail === this.head;    }

    size(): number {        return this.tail - this.head;    }}

Ahora las operaciones enqueue y dequeue se ejecutan en O(1) — tiempo constante, independientemente