¿Cómo elimino un elemento en particular de una serie en JavaScript?

Tengo una serie de números y estoy usando el .push() el método para agregar elementos a esto.

¿Hay alguna manera simple de eliminar un elemento simple de una serie? El equivalente de algo como array.remove(number);.

Tengo que usar JavaScript solo, no se permiten bibliotecas.

  • javascript
  • arrays
7 Repuestas

Encuentra la index de la serie de elementos que quieres eliminar, entonce quita el índice con splice.

El método splice() cambia el contenido de una serie eliminando elementos existentes y/o agregando nuevos elementos.

var array = [2, 5, 9];
console.log(array)
var index = array.indexOf(5);
if (index > -1) {
  array.splice(index, 1);
}
// array = [2, 9]
console.log(array);

El segundo parámetro de splice es el número de elementos a eliminar. Ten en cuenta que splice modifica la serie en su lugar y devuelve una nueva serie que contiene los elementos que se han eliminado.

No se como esperas array.remove(int) comportarte. Hay tres posibilidades puedo pensar que podrías estar deseando.

Quitar un elemento de una serie en un índice i:

array.splice(i, 1);

Si quieres eliminar cada elemento con un valor number desde la serie:

for(var i = array.length - 1; i >= 0; i--) {
    if(array[i] === number) {
       array.splice(i, 1);
    }
}

Si solo quieres hacer el elemento en el índice i no existe más, pero no quieres los índices del otro elemento para cambiar:

delete array[i];

Editado en octubre de 2016

  • Hazlo simple, intuitivo y explicito (Occam's Razor)
  • Hazlo inmutable (la serie original permanece sin cambios)
  • Hazlo con las funciones estándar de JS, si tu navegador no las admite - usa polyfill

En este código de ejemplo yo uso la función array.filter(...) para eliminar elementos no deseados de la serie, esta función no cambia la serie original y crea una nueva. Si tu navegador no soporta esta función (por ejemplo la versión 9 anterior o la versión 1.5 anterior), considera usar el filter polyfill de Mozilla.

Eliminar ítem (ECMA-262 Edición 5 código aka viejo JS)

var value = 3

var arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(function(item) {
    return item !== value
})

console.log(arr)
// [ 1, 2, 4, 5 ]

Elimina un ítem (codigo ES2015)

let value = 3

let arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(item => item !== value)

console.log(arr)
// [ 1, 2, 4, 5 ]

IMPORTANTE ES2015 "() => {}" la sintaxis de la función de flecha no es compatible con IE, Chrome versión anterior 45, Firefox versión anterior 22, Safari versión anterior 10. Para usar la sintaxis ES2015 en navegadores antiguos puedes usar BabelJS.

Quitar múltiples ítems (código ES2016)

Una ventaja adicional de este método es que puedes eliminar varios elementos

let forDeletion = [2, 3, 5]

let arr = [1, 2, 3, 4, 5, 3]

arr = arr.filter(item => !forDeletion.includes(item))
// !!! Read below about array.includes(...) support !!!

console.log(arr)
// [ 1, 4 ]

IMPORTANTE array.includes(...) la función que no es soportada en IE, Chrome 47 versión versión previa, Firefox 43 versión previa, Firefox 43 versión previa y Edge 14 versión previa por eso aquí está aqui es un polyfill de Mozilla.

Quitar múltiples ítems (Quizás en el futuro)

Si la propuesta "This-Binding Syntax" alguna vez aceptada podrás hacer esto:

// array-lib.js

export function remove(...forDeletion) {
    return this.filter(item => !forDeletion.includes(item))
}

// main.js

import { remove } from './array-lib.js'

let arr = [1, 2, 3, 4, 5, 3]

// :: This-Binding Syntax Proposal
// using "remove" function as "virtual method"
// without extending Array.prototype
arr = arr::remove(2, 3, 5)

console.log(arr)
// [ 1, 4 ]

Probarlo en BabelJS :)

Referencias

Depende de si quieres mantener un lugar vacío o no.

Si no quieres mantener un espacio vacío, está bien borrar:

delete array[ index ];

Y si no, deberías usar el método splice

array.splice( index, 1 );

Y si necesitas el valor de ese elemento, simplemente puedes almacenar el elemento devuelto de la serie:

var value = array.splice( index, 1 )[0];

En el caso de que quieras hacerlo en cierto orden, puedes usar array.pop() para la última o array.shift() para la primera (y ambos también devuelven el valor del ítem).

Y si no conces el índice el item también puedes usar array.indexOf( item ) para conseguir (en un if() para conseguir un ítem o en un while()para conseguirlos a todos) array.indexOf( item ) devuelve ya sea el índice o -1 si no se encuentra.

Un amigo estuvo teniendo problemas en Internet Explorer 8, y me mostró que fue lo que hizo. Le dije que estaba mal y el me dijo que saco la respuesta de aquí. La respuesta principal actual no funcionará en todos los navegadores (por ejemplo, Internet Explorer 8), solo eliminarán la primera aparición del elemento.

Eliminar TODAS las instancias de una serie

function remove(arr, item) {
    for (var i = arr.length; i--;) {
        if (arr[i] === item) {
            arr.splice(i, 1);
        }
    }
}

Esto recorre la serie hacia atrás (ya que los índices y la longitud cambiarán a medida que se eliminen los elementos) y elimina el elemento si es encontrado. Funciona en todos los navegadores.

Hay dos enfoques principales:

  1. empalme: anArray.splice(index, 1);
  2. borrar: delete anArray[index];

Ten cuidado cuando uses eliminar para una serie. Esto es bueno para elininar atributos de un objeto pero no es muy bueno para series. Es mejor usar splice para series.

Ten en mente que cuando usas delete en una serie pordrias obtener resultados incorrectos para .length. En otras palabras, delete eliminaría los elementos pero no ls actualizaría valor de propiedad de longitud.

Además puedes esperar tener agujeros en los números de índice después de usar eliminar, por ejemplo, podrías terminar teniendo índices 1,3,4,8,9,11 y la longitud tal como estaban antes de usar eliminar. En este caso, todos los bucles for indexados se bloquearían, ya que los índices ya no son secuenciales.

Si estás forzdo a usar delete por alguna razón, entonces deberías usar for each los bucles cuando necesites recorrer las series De hecho, si es posible, siempre evita usar indexados para bucles. De esa manera, el código sería más robusto y menos propenso a problemas con los índices.