Métodos pop y delete en arrays

Domina cómo eliminar elementos de un array con pop y un método personalizado delete dentro de una clase en JavaScript. Aprenderás a usar this, la length y la reindexación para mantener la estructura del array, devolviendo siempre el elemento eliminado. Explicación clara, ejemplos y código listos para usar.

¿Cómo eliminar el último elemento con pop en JavaScript?

Eliminar el último elemento es directo con pop: identifica el índice final con length - 1, guarda el valor, usa el keyword delete para borrarlo del objeto data y reduce la length en 1. Así, también sabes qué elemento fue borrado, porque pop debe retornarlo.

¿Por qué usar length - 1 para el último índice?

• Los índices inician en cero.
• Si length es 3, el último índice es 2.
• Evitas acceder a un índice que no existe.

¿Cómo se implementa pop dentro de una clase?

class MyArray {
  constructor() {
    this.length = 0;
    this.data = {};
  }
  // ... get y push ya implementados previamente.

  pop() {
    const lastIndex = this.length - 1;
    const lastItem = this.data[lastIndex];
    delete this.data[lastIndex]; // keyword delete borra la propiedad.
    this.length--;
    return lastItem;
  }
}

Puntos clave:

• this.data[this.length - 1] obtiene el último elemento.
• delete borra esa posición del objeto interno.
• this.length-- mantiene la longitud correcta del array.

¿Cómo borrar por índice y reacomodar con delete y shift index?

Cuando no borras el último elemento, necesitas reacomodar índices. La idea: desde el índice eliminado, cada elemento se recorre una posición a la izquierda. Después, se borra el último duplicado y se reduce length.

¿Cuál es la diferencia entre el keyword delete y el método delete?

• delete (palabra reservada): borra una propiedad del objeto, por ejemplo, delete this.data[i].
• delete (método de la clase): tu método personalizado que recibe un index, reacomoda y devuelve el elemento borrado.

¿Cómo reindexar eficientemente con shift index?

• Inicia el bucle en el índice a borrar para evitar recorrer desde cero.
• Copia el valor de i + 1 en i para “correr” los elementos a la izquierda.
• Borra el último índice y reduce length.

class MyArray {
  constructor() {
    this.length = 0;
    this.data = {};
  }
  // ... get y push ya implementados previamente.

  shiftIndex(index) {
    for (let i = index; i < this.length - 1; i++) {
      this.data[i] = this.data[i + 1];
    }
    delete this.data[this.length - 1];
    this.length--;
  }

  delete(index) {
    const item = this.data[index];
    this.shiftIndex(index);
    return item;
  }
}

Ejemplo práctico:

• Agrega: Diego, Karen, Óscar con push.
• pop() devuelve y borra Óscar (último).
• delete(1) borra Karen y mueve Óscar a índice 1.

¿Qué habilidades desarrollas y qué sigue?

Este contenido fortalece tu base en estructuras de datos con clases de JavaScript:

• Manejo de this, constructor, métodos y organización en clases.
• Uso de índices y length para direccionar el último elemento.
• Diferencia entre keyword delete y método personalizado delete.
• Reindexación con un bucle optimizado iniciando en el índice objetivo.
• Patrón de retorno: el método devuelve el elemento eliminado.

Reto propuesto:

• Implementa un método para agregar un elemento al inicio del array.
• Implementa un método para eliminar un elemento al inicio del array.

¿Te animas a compartir tu solución o una mejora al algoritmo de reindexación? Deja tus ideas y dudas en los comentarios.