No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Remover elementos con remove() y removeChild()

13/27
Recursos

¿Cómo eliminar elementos en el DOM usando JavaScript?

Eliminar elementos del DOM es una parte vital del desarrollo web dinámica, permitiendo que las aplicaciones respondan a las interacciones y necesidades del usuario en tiempo real. Puede que necesites eliminar elementos obsoletos, innecesarios o simplemente por diseño de la funcionalidad de tu aplicación. Aquí aprenderemos cómo hacerlo utilizando JavaScript.

¿Cuáles son las principales formas de eliminar elementos?

Existen dos métodos principales para eliminar elementos del DOM:

  1. Método remove: Este es un método directo que actúa sobre el elemento que deseas eliminar. Simplemente identificas el elemento, llamas al método remove() y este eliminará el elemento del DOM.

    // Seleccionamos el primer elemento de la lista
    const firstItem = document.querySelector('li');
    
    // Eliminamos el primer elemento
    firstItem.remove();
    
  2. Método removeChild: Este método implica un poco más de trabajo, pues debe aplicarse sobre el elemento padre del nodo que deseas eliminar. Es útil cuando se quiere eliminar un elemento específico dentro de ciertos criterios jerárquicos en el DOM.

    // Seleccionamos el contenedor o lista
    const list = document.querySelector('ul');
    
    // Eliminamos el primer elemento hijo de la lista
    list.removeChild(list.firstElementChild);
    

¿Cómo se implementa remove en la práctica?

remove() es útil cuando ya tienes una referencia directa al elemento que deseas eliminar. Utilizas document.querySelector para obtener ese elemento y llamas a remove() sobre él.

Por ejemplo, si tienes una lista de tareas y deseas eliminar la primera tarea:

// Asumimos que el elemento que queremos borrar es el primer elemento 'li'
const task = document.querySelector('li'); 
task.remove();

¿Cuándo usar removeChild?

removeChild es útil cuando necesitas recurrir al contexto del nodo padre para remover uno de sus hijos, por ejemplo, si no tienes una referencia directa al nodo hijo, pero sí al padre.

Esto es típico en una lista (ul o ol), donde quieres eliminar, por ejemplo, el primer o último elemento de la lista:

// Obtenemos el nodo padre
const parentList = document.querySelector('ul');

// Removemos el primer hijo
parentList.removeChild(parentList.firstElementChild);

Consejo práctico

  • Escoge el método que conviene a tu situación: Usa remove para máxima sencillez y cuando tengas una referencia directa al elemento. Usa removeChild cuando trabajas con dinámicas de nodos padres e hijos y necesites más control.
  • Combínalos con eventos: Estos métodos son altamente potentes cuando se combinan con eventos de usuario, como un click en un botón de "eliminar" para ítems en una lista.

Atrévete a aplicar estos métodos en tus proyectos de desarrollo web. La manipulación del DOM es una habilidad esencial para construir aplicaciones interactivas y responsivas, y eliminar elementos es solo una de las muchas facetas que lo hacen posible. Sigue explorando y mejorando tus habilidades, ¡el mundo del desarrollo web es vasto y lleno de oportunidades!

Aportes 9

Preguntas 1

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Si queremos eliminar un elemento li que no sea el primero o el último, podemos utilizar: list.removeChild(list.children\[2]); \*\[ ] número de la posición o index del elemento que queremos eliminar.
Otras propiedades con removeChild() * firstElementChild: Selecciona el primer hijo de tipo elemento * lastElementChild: Selecciona el último hijo de tipo elemento * childNodes\[index]: Selecciona el hijo específico por su índice * querySelector: También se puede usar con removeChild() para seleccionar y eliminar un elemento específico
* `remove()`: Elimina directamente el elemento seleccionado. * `removeChild()`: Elimina un hijo específico de un elemento, útil con propiedades como `firstElementChild`, `lastElementChild`, `childNodes[index]`, o `querySelector`. ```js // Seleccionamos el primer
  • con querySelector y lo mostramos en consola (ITEM 1) const firstItem = document.querySelector(`li`); console.log(firstItem); // Muestra:
  • Item 1
  • // Eliminamos el primer
  • directamente usando el método remove() firstItem.remove(); // Elimina el
  • que se seleccionó // Seleccionamos la lista
      y eliminamos su primer hijo usando removeChild const list = document.querySelector(`ul`); list.removeChild(list.firstElementChild); // Elimina el primer
    • dentro de la
        // - firstElementChild: Selecciona y elimina el primer hijo de tipo elemento // - lastElementChild: Selecciona y elimina el último hijo de tipo elemento // - childNodes[index]: Selecciona y elimina un hijo específico por su índice // - querySelector: También se puede usar para seleccionar un hijo específico y eliminarlo ```
  • Yo lo realice de esta forma por si les sirva ![](https://static.platzi.com/media/user_upload/upload-c304b48e-ed56-4bbe-a860-dc4013782899.png)
    Olvidaba para que servia el meth removeChild()
    El método `removeChild()` se utiliza para eliminar un nodo hijo de un elemento padre en el DOM. La sintaxis es: ```javascript parentNode.removeChild(childNode); ``` **Ejemplo:** Supón que tienes una lista en HTML: ```html
    • Elemento 1
    • Elemento 2
    • Elemento 3
    ``` Para eliminar el segundo elemento, primero seleccionas el padre y luego el hijo a eliminar: ```javascript const list = document.getElementById("myList"); const itemToRemove = list.children[1]; // Selecciona el segundo elemento list.removeChild(itemToRemove); // Elimina el elemento ``` Después de ejecutar el código, la lista tendrá solo "Elemento 1" y "Elemento 3".
    Otra forma de eliminar el primer hijo de la lista haciendo uso del remove sin tener al hijo en una variable específica (como con el "firstItem" del primer ejemplo) es la siguiente: En vez de hacer un: "list.removeChild(list.firstElementChild)" Otra forma de hacerlo es directamente con: "list.firstElementChild.remove()" Aunque lo chévere de removeChild es que te retorna el elemento que borraste y además, si quieres asegurarte de que el elemento que estás eliminando es un hijo y no otro elemento, si cometes un accidente escribiendo el código el mismo método devolverá un error en caso de que el elemento que pases como argumento no sea uno de los hijos. Cosa que no sucede con remove. Hay que tener cuidado con eso ✨.
    Esta clase me plantea la siguiente duda, al usar query accedemos al nodo del DOM get element accedemos al html, verdad? (esta no es la duda) cuando yo hago :```js const x= querySelector("li") ```primera pregunta: lo que estoy haciendo es creando un apuntador a ese objeto del doom y son estos objetos del doom los que tienen estos metodos remove y removechild verdad? ahora si yo hipoteticamente hiciera esto y esto tuviera sentido estaria no apuntando a un nodo sino a un objeto html ```js const x= getElementById("li") ```