Cómo crear colas en JavaScript

Las colas son una estructura similar a un array, aunque con ciertas restricciones. En JavaScript no existe una implementación para las colas por defecto.  Sin embargo. podemos implementarlas nosotros, que es lo que veremos en este tutorial.

Qué es una cola

Una cola es una estructura que consta de varios elementos que se ordenan secuencialmente, del mismo modo que un array. Sin embargo, solamente podremos agregar elementos a la cola por el final de la misma. Del mismo modo, solamente será posible eliminar elementos de la parte delantera de la cola.

Las colas funcionan exactamente igual que las del supermercado. El primero en esperar en la cola, será el primero en salir de ella, salvo que abran una caja nueva y vayas corriendo, pero esa es otra historia.

El concepto del funcionamiento de las colas recibe el nombre de FIFO (First In, First Out).

Mientras que los arrays son una estructura de datos incluida con JavaScript, no existe una estructura nativa para las colas, por lo que en caso de querer usarlas tendremos que implementar una nueva estructura.

Métodos de una cola

Vamos a crear una estructura de datos que encapsule nuestros datos, de forma que cumpla con los requisitos de las colas. Necesitaremos los siguientes métodos:

• Método add(): Este método agregará un nuevo elemento al final de la cola.
• Método remove(): Este método eliminará un elemento del inicio de la cola.

Además, también agregaremos tres métodos de apoyo adicionales:

• Método isempty(): Este método comprueba si la cola está vacía.
• Método empty(): Este método eliminará todos los elementos de la cola..
• Método size(): Este método devuelve el número de elementos de la cola.

Implementación de una cola

Vamos a implementar una cola con una clase JavaScript. Los elementos de la cola los almacenaremos en un array al que llamaremos elementos:

class Cola {
  elementos = [];
  
  add = (elemento) => {
    return this.elementos.splice(0, 0, elemento);
  }
  remove = () => {
    return this.elementos.pop();
  }
  isempty = () => {
    return this.elementos.length === 0;
  }
  empty = () => {
    this.elementos.length = 0;
  }
  size = () => {
    return this.elementos.length;
  }
}

Ahora ya podemos crear una cola y agregar o eliminar elementos de la misma:

const cola = new Cola();
cola.add(1);
cola.add(2);
cola.add(3);
console.log(cola.size()); //3

consola.log(cola.remove()); // 1
consola.log(cola.remove()); // 2
consola.log(cola.remove()); // 3

Ahora ya tendríamos nuestra cola implementada. Sin embargo, estaría bien que el array de elementos fuese privado.

Por ejemplo, actualmente, podemos obtener el número de elementos de la cola accediendo al array elementos, algo que resta solidez a la cola:

const cola = new Cola();
cola.add('a');
console.log(cola.elementos); // 2

Para solucionar ese problema debemos declarar el atributo elementos como privado.

Cola con elementos privados

El código que usaremos será el mismo que hemos usado en el caso anterior, salvo que antepondremos el símbolo # al atributo elementos para declararlo como privado:

class Cola {
  #elementos = [];
  
  add = (elemento) => {
    return this.#elementos.splice(0, 0, elemento);
  }
  remove = () => {
    return this.#elementos.pop();
  }
  isempty = () => {
    return this.#elementos.length === 0;
  }
  empty = () => {
    this.#elementos.length = 0;
  }
  size = () => {
    return this.#elementos.length;
  }
}

Si ahora intentamos acceder a la propiedad cola.#elementos desde fuera, obtendremos undefined, ya que no es posible acceder al elemento. Sin embargo, debes tener en cuanta que los atributos privados en JavaScript son todavía algo experimental. Están disponibles en Chrome, Edge, Safari y también en las últimas versiones de Node.js, pero todavía no se recomienda su uso.

Y esto ha sido todo.

---