Cómo crear pilas en JavaScript

Las pilas o stacks son una estructura similar a un array, aunque con ciertas restricciones. En JavaScript no existe una implementación para las pilas, pero podemos implementarlas nosotros, que es lo que veremos en este tutorial.

Qué es una pila

Una pila es una estructura que consta de varios elementos que se ordenan secuencialmente, al igual que un array. Sin embargo, solamente podremos agregar elementos a la pila encima del resto. Del mismo modo, solamente será posible eliminar elementos de la parte superior de la pila.

Esta filosofía es la misma que sigues cuando creas una pila de libros. Para agregar un nuevo libro a la pila, lo añades en la parte superior y, en caso de querer acceder a un libro que esté en medio de la pila, tendrás que quitar todos los que haya encima para poder acceder a él.

El concepto del funcionamiento de las pilas recibe el nombre de LIFO (Last In, First Out).

Mientras que los arrays son una estructura de datos incluida con JavaScript, no existe una estructura nativa para las pilas, por lo que de querer usar una pila, tendrás que implementarla.

Métodos de una pila

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

• Método push(): Este método agregará un nuevo elemento a la parte superior de la pila.
• Método pop(): Este método eliminará un elemento de la parte superior de la pila.

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

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

Implementación de una pila

Implementaremos la pila como una clase JavaScript y almacenaremos los elementos de la pila en un array al que llamaremos elementos:

class Pila {
  elementos = [];
  
  push = (elemento) => {
    return this.elementos.push(elemento);
  }
  pop = () => {
    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 pila, agregar elementos a la misma o eliminarlos:

const pila = new Pila():

// Agregamos elementos a la pila
pila.push('a');
pila.push('b');
pila.push('c');
console.log(pila.size()); // 3
console.log(pila.pop()); // 'c'
console.log(pila.size()); // 2

Recuerda que el método pop(), además de eliminar un elemento, devuelve el elemento que eliminamos de la pila. Por eso se muestra 'c' por la consola.

Y con esto ya estaría la pila implementada. Sin embargo, lo ideal sería que no pudiésemos modificar el array de elementos desde fuera de la clase, ya que de lo contrario podrían producirse efectos indeseados.

Por ejemplo, actualmente, podemos obtener el número de elementos de la pila accediendo al array elementos:

const pila = new Pila();
pila.push('a');
console.log(pila.elementos); // 2

Podemos solucionar ese problema si declaramos el atributo elementos como privado.

Pila 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 Pila {
  #elementos = [];
  
  push = (elemento) => {
    return this.#elementos.push(elemento);
  }
  pop = () => {
    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 pila.#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.

---