79 Pregunta: ¿Cómo elimino un elemento en particular de una matriz en JavaScript?

pregunta creada en Thu, Feb 14, 2019 12:00 AM

Tengo una matriz de Números y estoy usando el método .push() para agregarle elementos.

¿Existe una forma sencilla de eliminar un elemento específico de una matriz? El equivalente de algo así como array.remove(number);.

Tengo que usar core JavaScript - no los marcos están permitidos.

    
7214
  1. Si necesita admitir < IE9 ( sigh ), marque esta pregunta de SO sobre indexOf en IE.
    2013-09-13 07: 48: 49Z
  2. (lodash) array = ['a', 'b', 'c']; _.pull (array, 'a') //array = > ['antes de Cristo']; Consulte también stackoverflow.com/questions/5767325/…
    2015-08-25 20: 28: 43Z
  3. método de filtro puede hacer lo que quieras.
    2015-09-05 23: 43: 21Z
  4. Puedes usar delete pero no reajusta el índice, sino que establecerá esta ranura en 'indefinido × 1'. Por ejemplo: var list = [1,2,3,4,5,6] - > eliminar lista [1] - > [1, indefinido × 1, 3, 4, 5, 6].
    2016-05-24 23: 26: 45Z
  5. Aquí se presenta una referencia de rendimiento de las dos principales posibilidades: jsben .ch /# /b4Ume
    2017-03-03 16: 46: 45Z
30 Respuestas                              30                         

Encuentre el index del elemento de matriz que desea eliminar, luego elimine ese índice con splice .

  

El método splice () cambia el contenido de una matriz eliminando   Elementos existentes y /o añadiendo 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 que se eliminarán. Tenga en cuenta que splice modifica la matriz en su lugar y devuelve una nueva matriz que contiene los elementos que se han eliminado.

    
10357
2019-02-17 00: 02: 23Z
  1. @ Peter, puede que tengas razón. Este artículo explica más y tiene una solución alternativa para navegadores incompatibles: developer.mozilla. org /es /JavaScript /Reference /Global_Objects /…
    2011-04-23 22: 28: 10Z
  2. ¡Peligroso! Si está trabajando con valores dinámicos (agregue y elimine valores dinámicos de la matriz) y el valor no existe en la matriz (el índice se convierte en -1), el código anterior eliminará el último elemento de la matriz.
    2013-09-06 16: 44: 17Z
  3. @ AlexandreWiechersVaz Por supuesto que conserva el orden, si no lo hiciera, sería absolutamente inútil
    2013-12-11 19: 18: 02Z
  4. Puede superar el problema de compatibilidad del navegador IE incluyendo el código dado aquí
    2014-06-08 10: 42: 27Z
  5. @ AdrianP. array.indexOf(testValue) en una matriz vacía será -1, y si está probando eso, entonces no hay empalme. Tal vez la respuesta haya cambiado desde entonces.
    2015-01-19 15: 47: 21Z

No sé cómo espera que se comporte el array.remove(int). Hay tres posibilidades en las que puedo pensar que podrías estar deseando.

Para eliminar un elemento de una matriz en un índice i:

 
array.splice(i, 1);

Si desea eliminar todos los elementos con valor number de la matriz:

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

Si solo desea que el elemento en el índice i ya no exista, pero no desea que cambien los índices de los otros elementos:

 
delete array[i];
    
1077
2018-12-18 17: 42: 12Z
  1. delete no es la forma correcta de eliminar un elemento de una matriz.
    2013-01-27 15: 30: 48Z
  2. @ FelixKling Depende, funciona si quieres que sea array.hasOwnProperty(i) devuelve false y el elemento en esa posición devuelve undefined. Pero debo admitir que no es algo muy común que se quiera hacer.
    2013-01-27 15: 36: 52Z
  3. delete no actualizará la longitud de la matriz ni borrará realmente el elemento, solo lo reemplazará con el valor especial undefined.
    2013-02-17 03: 44: 59Z
  4. @ diosney No sé a qué te refieres cuando dices que realmente no borra el elemento. Además, hace más que simplemente reemplazar el valor en ese índice con undefined: elimina tanto el índice como el valor de la matriz, es decir, después de delete array[0], "0" in array devolverá false.
    2013-04-15 19: 13: 42Z
  5. delete es un buen mecanismo si se trata de propiedades con nombre var array=[];array['red']=1;array['green']=2;array['blue']=3;delete array['green'];
    2014-10-21 23: 00: 59Z

Editado el 2016 de octubre

En este ejemplo de código, uso la función "array.filter (...)" para eliminar elementos no deseados de la matriz, esta función no cambia la matriz original y crea una nueva. Si su navegador no admite esta función (por ejemplo, IE antes de la versión 9, o Firefox antes de la versión 1.5), considere usar el polyfill del filtro de Mozilla .

Eliminación de elementos (ECMA-262 Edición 5 código aka oldstyle 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 ]

Eliminando elemento (código 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 antes de la versión 45, Firefox antes de la versión 22, Safari antes de la versión 10. Para usar la sintaxis de ES2015 en navegadores antiguos, puede usar BabelJS


Eliminación de varios elementos (código ES2016)

Una ventaja adicional de este método es que puede 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 ]
La función

IMPORTANTE "array.includes (...)" no es compatible con IE, Chrome antes de la versión 47, Firefox antes de la versión 43, Safari antes de la versión 9 y Edge antes de la versión 14, por lo que aquí está polyfill de Mozilla

Eliminando varios elementos (en el futuro, tal vez)

Si el " Esta sintaxis de vinculación " siempre se acepta la propuesta, podrá 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 ]

Pruébelo usted mismo en BabelJS :)

Referencia

906
2019-06-23 08: 16: 58Z
  1. pero, a veces, queremos eliminar el elemento de la matriz original (no inmutable), por ejemplo, la matriz utilizada en la directiva Angular 2 * ngFor
    2017-02-08 14: 06: 04Z
  2. Mejor que la solución aceptada porque no asume solo una aparición de una coincidencia y es preferible la inmutabilidad
    2017-03-06 16: 46: 21Z
  3. filter debe ser mucho más lento para una gran matriz, ¿no?
    2017-07-17 01: 02: 59Z
  4. ¿Cuál es el punto de inmutabilidad mencionado si usaste la asignación de la misma variable en tus ejemplos? :)
    2017-08-19 11: 36: 51Z
  5. Esta es una gran respuesta. El empalme es una función especializada para mutar, no para filtrar. filter puede tener un rendimiento más lento, pero es un código más seguro y mejor. Además, puede filtrar por índice especificando un segundo argumento en la lada: arr.filter((x,i)=>i!==2)
    2018-08-15 12: 50: 44Z

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

Si desea una ranura vacía, eliminar está bien:

 
delete array[ index ];

Si no lo hace, debe usar el método de splice :

 
array.splice( index, 1 );

Y si necesita el valor de ese elemento, simplemente puede almacenar el elemento de la matriz devuelta:

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

En caso de que quieras hacerlo en algún orden, puedes usar array.pop() para el último o array.shift() para el primero (y ambos también devuelven el valor del artículo).

Y si no conoce el índice del elemento, puede usar array.indexOf( item ) para obtenerlo (en un if() para obtener un elemento o en un while() para obtener todos). array.indexOf( item ) devuelve el índice o -1 si no se encuentra.

    
401
2014-07-10 22: 43: 25Z
  1. Vale la pena notar que var value no almacenará el valor eliminado sino una matriz que contiene el valor eliminado.
    2013-07-10 09: 55: 45Z
  2. delete no es la forma correcta de eliminar un elemento de una matriz.
    2014-07-04 14: 20: 43Z
  3. Si desea "vaciar una ranura", use array[index] = undefined;. El uso de delete destruirá la optimización.
    2014-08-11 16: 40: 29Z
  4. @ Jakub verEs un buen comentario porque entiendo que perdí mucho tiempo y pensé que mi código de aplicación está roto de alguna manera ...
    2014-12-14 19: 14: 58Z
  5. El último párrafo con la explicación de lo que obtienes de indexOf fue realmente útil
    2019-02-05 16: 31: 34Z

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

Eliminar TODAS las instancias de una matriz

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

Recorre la matriz hacia atrás (ya que los índices y la longitud cambiarán a medida que se eliminen los elementos) y elimina el elemento si se encuentra. Funciona en todos los navegadores.

    
255
2018-06-08 08: 26: 59Z
  1. @ sroes no debería ser porque el ciclo comienza en i = arr.length -1 o i-- haciéndolo igual que el índice máximo. arr.length es solo un valor inicial para i. i-- siempre será truthy (y se reducirá en 1 en cada bucle op) hasta que sea igual a 0 (un valor falsy) y el bucle se detendrá.
    2014-01-29 20: 06: 34Z
  2. La segunda función es bastante ineficiente. En cada iteración, "indexOf" comenzará la búsqueda desde el principio de la matriz.
    2015-02-25 13: 32: 12Z
  3. @ AmberdeBlack, en una colección con más de 1 aparición de elemento , es mucho mejor llamar al filtro en lugar del método arr.filter(function (el) { return el !== item }), evitando la necesidad de mutar la matriz varias veces. Esto consume un poco más de memoria, pero funciona de manera mucho más eficiente, ya que hay menos trabajo por hacer.
    2015-03-30 09: 37: 04Z
  4. @ AlJey, está disponible solo para IE9 +. Todavía existe la posibilidad de que no funcione.
    2015-03-30 16: 23: 56Z
  5. Esta respuesta me funcionó porque necesitaba eliminar varios elementos pero no en ningún orden en particular. La progresión hacia atrás del bucle for aquí maneja la eliminación perfecta de elementos de la matriz.
    2015-07-14 23: 39: 58Z

Hay dos enfoques principales:

  1. splice () : anArray.splice(index, 1);

  2. eliminar : delete anArray[index];

Tenga cuidado cuando use eliminar para una matriz. Es bueno para eliminar atributos de objetos pero no tan bueno para arreglos. Es mejor usar splice para arreglos.

Tenga en cuenta que cuando usa delete para una matriz, puede obtener resultados incorrectos para anArray.length. En otras palabras, delete eliminaría el elemento pero no actualizaría el valor de la propiedad length.

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

Si se ve obligado a usar delete por algún motivo, entonces debe usar for each se reproduce en bucle cuando necesita recorrer los arreglos. De hecho, siempre evite usar indexados para bucles, si es posible. De esa manera, el código sería más robusto y menos propenso a problemas con los índices.

    
150
2017-10-03 12: 04: 03Z
 
Array.prototype.remByVal = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] === val) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
}
//Call like
[1, 2, 3, 4].remByVal(3);

 
Array.prototype.remByVal = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] === val) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
}

var rooms = ['hello', 'something']

rooms = rooms.remByVal('hello')

console.log(rooms)
    
125
2017-09-25 04: 56: 18Z
  1. No soy un gran fanático de este enfoque. Si terminas usando bibliotecas o marcos diferentes, pueden terminar en conflicto entre ellos.
    2011-04-23 22: 30: 15Z
  2. Esto también funcionó, pero elegí ir con la función indexOf al final. ¡Gracias por la ayuda!
    2011-04-23 22: 35: 58Z
  3. 2012-07-09 22: 10: 08Z
  4. Si estás haciendo un for in en una matriz, ya tienes un problema.
    2014-05-14 13: 01: 58Z
  5. si haces for in en arreglos, ya tienes problemas más grandes.
    2018-08-01 06: 20: 21Z

No hay necesidad de usar indexOf o splice. Sin embargo, funciona mejor si solo desea eliminar una aparición de un elemento.

Buscar y mover (mover):

 
function move(arr, val) {
  var j = 0;
  for (var i = 0, l = arr.length; i < l; i++) {
    if (arr[i] !== val) {
      arr[j++] = arr[i];
    }
  }
  arr.length = j;
}

Utilice indexOf y splice (indexof):

 
function indexof(arr, val) {
  var i;
  while ((i = arr.indexOf(val)) != -1) {
    arr.splice(i, 1);
  }
}

Utilice solo splice (empalme):

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

Tiempos de ejecución en nodejs para una matriz con 1000 elementos (un promedio de más de 10000 ejecuciones):

indexof es aproximadamente 10 veces más lento que mover . Incluso si se mejoró al eliminar la llamada al indexOf en splice , se realiza mucho peor que mover .

 
Remove all occurrences:
    move 0.0048 ms
    indexof 0.0463 ms
    splice 0.0359 ms

Remove first occurrence:
    move_one 0.0041 ms
    indexof_one 0.0021 ms
    
92
2015-09-11 12: 47: 59Z
  1. Parece que el método de 'movimiento' que se presenta aquí debería funcionar en todos los navegadores, y también evita la creación de una matriz adicional; La mayoría de las otras soluciones aquí tienen uno o ambos de estos problemas. Creo que este merece muchos más votos, incluso si no parece "bonito".
    2015-07-29 11: 50: 21Z

Demasiado viejo para responder, pero puede ayudar a alguien, proporcionando un predicado en lugar de un valor.

NOTA: actualizará la matriz dada y devolverá las filas afectadas

Uso

 
var removed = helper.removeOne(arr, row => row.id === 5 );

var removed = helper.remove(arr, row => row.name.startsWith('BMW'));

Definición

 
var helper = {

    // Remove and return the first occurrence     

    removeOne: function(array, predicate) {
        for (var i = 0; i < array.length; i++) {
            if (predicate(array[i])) {
                return array.splice(i, 1);
            }
        }
    },

    // Remove and return all occurrences  

    remove: function(array, predicate) {
        var removed = [];

        for (var i = 0; i < array.length;) {

            if (predicate(array[i])) {
                removed.push(array.splice(i, 1));
                continue;
            }

            i++;                
        }

        return removed;
    }
};
    
62
2016-12-26 10: 57: 02Z
  1. No sé si necesita la comprobación -1 (i > -1). Además, creo que estas funciones actúan más como un filtro que como una eliminación. Si pasa row.id === 5, dará como resultado una matriz con solo id 5, por lo que está haciendo lo contrario a eliminar. Se vería bien en ES2015: var result = ArrayHelper.remove (myArray, row = > row.id === 5);
    2015-09-20 19: 42: 45Z
  2. @ WhatWouldBeCool esta función modifica la matriz original y devuelve el elemento eliminado en lugar de copiar el resultado en una nueva matriz
    2015-09-21 07: 21: 13Z

John Resig publicó una buena implementación :

 
// Array Remove - By John Resig (MIT Licensed)
Array.prototype.remove = function(from, to) {
  var rest = this.slice((to || from) + 1 || this.length);
  this.length = from < 0 ? this.length + from : from;
  return this.push.apply(this, rest);
};

Si no lo haces ’Si desea extender un objeto global, puede hacer algo como lo siguiente, en su lugar:

 
// Array Remove - By John Resig (MIT Licensed)
Array.remove = function(array, from, to) {
    var rest = array.slice((to || from) + 1 || array.length);
    array.length = from < 0 ? array.length + from : from;
    return array.push.apply(array, rest);
};

Pero la razón principal por la que publico esto es para advertir a los usuarios sobre la implementación alternativa que se sugiere en los comentarios de esa página (14 de diciembre de 2007):

 
Array.prototype.remove = function(from, to){
  this.splice(from, (to=[0,from||1,++to-from][arguments.length])<0?this.length+to:to);
  return this.length;
};

Parece que funciona bien al principio, pero a través de un proceso doloroso descubrí que falla al intentar eliminar el elemento del segundo al último en una matriz. Por ejemplo, si tiene una matriz de 10 elementos e intenta eliminar el noveno elemento con esto:

 
myArray.remove(8);

Terminas con una matriz de 8 elementos. No sé por qué, pero confirmé que la implementación original de John no tiene este problema.

    
58
2015-02-16 12: 51: 30Z
  1. Aprendí de la manera más difícil por qué es una buena idea usar Object.prototype.hasOwnProperty siempre ¬¬
    2015-04-11 04: 58: 05Z

Underscore.js se puede utilizar para resolver problemas con varios navegadores. Utiliza métodos de navegador en la compilación si están presentes. Si están ausentes, como en el caso de versiones anteriores de Internet Explorer, utiliza sus propios métodos personalizados.

Un ejemplo simple para eliminar elementos de la matriz (del sitio web):

 
_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]
    
56
2017-05-21 11: 29: 54Z

Puede hacerlo fácilmente con el método filter :

 
function remove(arrOriginal, elementToRemove){
    return arrOriginal.filter(function(el){return el !== elementToRemove});
}
console.log( remove([1, 2, 1, 0, 3, 1, 4], 1) );

Esto elimina todos los elementos de la matriz y también funciona más rápido que la combinación de slice y indexOf

    
55
2014-02-10 22: 06: 01Z
  1. ¿Tiene una fuente que indique que esto es más rápido?
    2017-07-28 18: 21: 57Z
  2. Buena solución. Pero como señala, pero es importante que se vuelva calvo, no produce el mismo resultado que slice e indexOf, ya que eliminará todas las apariciones de 1
    2017-07-28 18: 28: 36Z
  3. @ user3711421 esto se debe a que solo slice e indexOf no hace lo que él quiere "para eliminar un elemento específico". Elimina el elemento solo una vez, esto elimina un elemento específico sin importar cuántos de ellos tengas
    2017-07-28 20: 05: 09Z

Si desea eliminar una nueva matriz con las posiciones eliminadas, siempre puede eliminar el elemento específico y filtrar la matriz. Es posible que necesite una extensión del objeto matriz para los navegadores que no implementan el método de filtro, pero a largo plazo es más fácil ya que todo lo que haces es esto:

 
var my_array = [1,2,3,4,5,6];
delete my_array[4];
console.log(my_array.filter(function(a){return typeof a !== 'undefined';}));

Debería mostrar [1, 2, 3, 4, 6]

    
46
2014-09-05 07: 59: 57Z

Puedes usar ES6.

 
var array=['1','2','3','4','5','6']
var index = array.filter((value)=>value!='3');

Salida:

 
["1", "2", "4", "5", "6"]
    
39
2016-11-19 08: 59: 00Z
  1. Esta respuesta es buena porque crea una copia de la matriz original, en lugar de modificar la original directamente.
    2017-03-16 15: 27: 40Z
  2. Nota: Array.prototype.filter es ECMAScript 5.1 (No IE8). para obtener soluciones más específicas: stackoverflow.com/a/54390552/8958729
    2019-01-27 19: 45: 05Z

Echa un vistazo a este código. Funciona en todos los principales navegadores .

 
remove_item = function (arr, value) {
    var b = '';
    for (b in arr) {
        if (arr[b] === value) {
            arr.splice(b, 1);
            break;
        }
    }
    return arr;
}

Llama a esta función

 
remove_item(array,value);
    
36
2014-05-24 07: 02: 53Z
  1. @ RolandIllig Excepto el uso de un for in -loop y el hecho de que el script se haya detenido antes, devolviendo el resultado directamente desde el bucle. Los upvotes son razonables;)
    2014-12-30 16: 13: 41Z
  2. Este es un excelente enfoque para arreglos pequeños. Funciona en todos los navegadores, utiliza código mínimo e intuitivo, y sin marcos, calzas o rellenos de relleno complejos adicionales.
    2016-08-21 23: 12: 41Z
  3. También debo reiterar el comentario de yckart de que for( i = 0; i < arr.length; i++ ) sería un mejor enfoque, ya que conserva los índices exactos en comparación con cualquier orden en el que el navegador decida almacenar los artículos (con for in). Al hacerlo, también le permite obtener el índice de matriz de un valor si lo necesita.
    2016-08-21 23: 20: 39Z

Puede utilizar lodash _.pull (matriz mutate), _. pullAt (matriz mutate) o _.sin (no muta la matriz),

 
var array1 = ['a', 'b', 'c', 'd']
_.pull(array1, 'c')
console.log(array1) // ['a', 'b', 'd']

var array2 = ['e', 'f', 'g', 'h']
_.pullAt(array2, 0)
console.log(array2) // ['f', 'g', 'h']

var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without(array3, 'i') // ['j', 'k', 'l']
console.log(array3) // ['i', 'j', 'k', 'l']
    
34
2015-08-25 21: 19: 16Z
  1. Eso no es el núcleo JS como solicitó el OP, ¿verdad?
    2015-09-24 21: 01: 50Z
  2. @ usuario no descriptivo Tienes razón. Pero muchos usuarios como yo vienen aquí en busca de una respuesta general, no solo para el OP solo.
    2015-10-01 03: 38: 30Z
  3. @ ChunYang Tienes toda la razón. Ya estoy usando lodash, ¿por qué no usarlo si ahorra tiempo?
    2018-06-08 21: 48: 30Z

OK, por ejemplo, tiene la siguiente matriz:

 
var num = [1, 2, 3, 4, 5];

Y queremos eliminar el número 4, simplemente puede hacer el siguiente código:

 
num.splice(num.indexOf(4), 1); //num will be [1, 2, 3, 5];

Si reutiliza esta función, escribe una función reutilizable que se adjuntará a la función de matriz nativa como se muestra a continuación:

 
Array.prototype.remove = Array.prototype.remove || function(x) {
  const i = this.indexOf(x);
  if(i===-1) return;
  this.splice(i, 1); //num.remove(5) === [1, 2, 3];
}

Pero, ¿qué tal si tiene la siguiente matriz en lugar de pocas [5] s en la matriz?

 
var num = [5, 6, 5, 4, 5, 1, 5];

Necesitamos un bucle para verificarlos todos, pero la forma más fácil y eficiente es usar las funciones incorporadas de JavaScript, por lo que escribimos una función que usa un filtro como el siguiente:

 
const _removeValue = (arr, x) => arr.filter(n => n!==x);
//_removeValue([1, 2, 3, 4, 5, 5, 6, 5], 5) //return [1, 2, 3, 4, 6]

También hay bibliotecas de terceros que lo ayudan a hacerlo, como Lodash o Underscore, para obtener más información, consulte lodash _.pull, _.pullAt o _.without.

    
32
2018-03-26 00: 23: 30Z
  1. Hay un pequeño error tipográfico. Por favor corrija this.splice(num.indexOf(x), 1); = > this.splice(this.indexOf(x), 1);
    2017-05-11 12: 28: 30Z
  2. Por favor, no aumente los elementos incorporados (adjunte funciones a Array.prototype) en JavaScript. Esto es ampliamente considerado como una mala práctica.
    2017-05-24 03: 29: 54Z
  3. Estoy de acuerdo en que no es lo mejor que se puede hacer en el mundo, pero en este caso, ¿cómo podría pasarlo a la función?
    2017-05-25 08: 45: 07Z
  4. Debe verificar el índice. Si index = -1, splice (-1,1) eliminará el último elemento
    2018-01-26 09: 38: 10Z

Aquí hay algunas maneras de eliminar un elemento de una matriz mediante JavaScript .

Todos los métodos descritos no mutan la matriz original , y en su lugar crean una nueva.

Si conoce el índice de un elemento

Suponga que tiene una matriz y desea eliminar un elemento en la posición i.

Un método es usar slice():

 
const items = ['a', 'b', 'c', 'd', 'e', 'f']
const i = 3
const filteredItems = items.slice(0, i).concat(items.slice(i+1, items.length))

console.log(filteredItems)

slice() crea una nueva matriz con los índices que recibe. Simplemente creamos una nueva matriz, desde el inicio hasta el índice que queremos eliminar, y concatenamos otra matriz desde la primera posición después de la que eliminamos hasta el final de la matriz.

Si conoces el valor

En este caso, una buena opción es utilizar filter(), que ofrece un enfoque más declarativo :

 
const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter(item => item !== valueToRemove)

console.log(filteredItems)

Esto utiliza las funciones de flecha ES6. Puede usar las funciones tradicionales para admitir navegadores más antiguos:

 
const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valueToRemove = 'c'
const filteredItems = items.filter(function(item) {
  return item !== valueToRemove
})

console.log(filteredItems)

o puedes usar Babel y transpilar el código ES6 de vuelta a ES5 para que sea más fácil de digerir para los navegadores antiguos, pero escribe JavaScript moderno en tu código.

Eliminando varios elementos

¿Qué sucede si, en lugar de un solo elemento, desea eliminar muchos elementos?

Encontremos la solución más sencilla.

Por índice

Puedes crear una función y eliminar elementos de la serie:

 
const items = ['a', 'b', 'c', 'd', 'e', 'f']

const removeItem = (items, i) =>
  items.slice(0, i-1).concat(items.slice(i, items.length))

let filteredItems = removeItem(items, 3)
filteredItems = removeItem(filteredItems, 5)
//["a", "b", "c", "d"]

console.log(filteredItems)

Por valor

Puede buscar la inclusión dentro de la función de devolución de llamada:

 
const items = ['a', 'b', 'c', 'd', 'e', 'f']
const valuesToRemove = ['c', 'd']
const filteredItems = items.filter(item => !valuesToRemove.includes(item))
// ["a", "b", "e", "f"]

console.log(filteredItems)

Evita mutar la matriz original

splice() (que no debe confundirse con slice()) muta la matriz original, y debe evitarse.

(publicado originalmente en https://flaviocopes.com/how-to -remove-item-from-array /)

    
29
2019-04-14 16: 39: 51Z
  1. Creo que en su ejemplo desea items.slice(0, i).concat(items.slice(i+1, items.length)), (0, i) en lugar de (0, i-1) porque el elemento 'end' de la matriz no está incluido en el resultado. Además, i + 1 está bien para la segunda parte, ya que devuelve una matriz vacía si se sale de los límites.
    2019-03-17 17: 02: 30Z
  2. Tienes razón. Lo arreglé en mi blog hace algún tiempo, ¡pero nunca lo cambié en la respuesta! Gracias por decirme
    2019-04-14 16: 40: 33Z

Soy bastante nuevo en JavaScript y necesitaba esta funcionalidad. Simplemente escribí esto:

 
function removeFromArray(array, item, index) {
  while((index = array.indexOf(item)) > -1) {
    array.splice(index, 1);
  }
}

Luego, cuando quiero usarlo:

 
//Set-up some dummy data
var dummyObj = {name:"meow"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];

//Remove the dummy data
removeFromArray(dummyArray, dummyObj);
removeFromArray(dummyArray, "item2");

Salida - como se esperaba. ["item1", "item1"]

Es posible que tengas necesidades diferentes a las que yo, por lo que puedes modificarlo fácilmente para que se adapte a ellas. Espero que esto ayude a alguien.

    
27
2014-12-30 16: 17: 43Z
  1. Esto tendrá un comportamiento terrible si su matriz es realmente larga y hay varias instancias del elemento en ella. El método de matriz indexOf comenzará al principio cada vez, por lo quesu costo será O (n ^ 2).
    2019-05-24 18: 22: 30Z

ES6 & sin mutación: (octubre 2016)

 
const removeByIndex = (list, index) =>
  [
    ...list.slice(0, index),
    ...list.slice(index + 1)
  ];

Entonces:

 
removeByIndex([33,22,11,44],1) //=> [33,11,44]
    
25
2016-10-07 19: 42: 51Z
  1. up up up up up uuuuuuuuuuuuup! ¡Esto está más actualizado, esto debería N ° 1 no responder N ° 20!
    2018-09-14 09: 28: 18Z

Actualización: este método se recomienda solo si no puede usar ECMAScript 2015 (anteriormente conocido como ES6). Si puede usarlo, otras respuestas aquí proporcionan implementaciones mucho más nítidas.


Esta idea aquí resolverá su problema y también eliminará todas las apariciones del argumento en lugar de solo 1 (o un valor especificado).

 
Array.prototype.destroy = function(obj){
    // Return null if no objects were found and removed
    var destroyed = null;

    for(var i = 0; i < this.length; i++){

        // Use while-loop to find adjacent equal objects
        while(this[i] === obj){

            // Remove this[i] and store it within destroyed
            destroyed = this.splice(i, 1)[0];
        }
    }

    return destroyed;
}

Uso:

 
var x = [1, 2, 3, 3, true, false, undefined, false];

x.destroy(3);         // => 3
x.destroy(false);     // => false
x;                    // => [1, 2, true, undefined]

x.destroy(true);      // => true
x.destroy(undefined); // => undefined
x;                    // => [1, 2]

x.destroy(3);         // => null
x;                    // => [1, 2]
    
23
2017-09-01 22: 41: 13Z

¿Si tiene objetos complejos en la matriz, puede usar filtros? En situaciones donde $.inArray o array.splice no es tan fácil de usar. Especialmente si los objetos son quizás poco profundos en la matriz.

Por ejemplo, Si tiene un objeto con un campo de identificación y desea que el objeto se elimine de una matriz:

 
this.array = this.array.filter(function(element, i) {
    return element.id !== idToRemove;
});
    
22
2015-11-10 04: 20: 21Z
  1. Así es como me gusta hacerlo. Usando una función de flecha puede ser de una sola línea. Tengo curiosidad por el rendimiento. Tampoco vale nada que este reemplace la matriz. Cualquier código con una referencia a la matriz antigua no notará el cambio.
    2016-07-29 08: 50: 36Z

Quiero responder en base a ES6 . Supongamos que tiene una matriz como la siguiente:

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

Si desea eliminar un índice especial como 2, escriba el código a continuación:

 
arr.splice(2, 1); //=> arr became [1,2,4]

Pero si desea eliminar un elemento especial como 3 y no sabe su índice, haga lo siguiente:

 
arr = arr.filter(e => e !== 3); //=> arr became [1,2,4]

Sugerencia : utilice una función de flecha para devolver el filtro a menos que obtenga una matriz vacía.

    
21
2019-02-24 12: 06: 30Z
  1. la última opción devolverá una matriz vacía
    2018-12-18 09: 24: 36Z
  2. @ Dejan.S, me sorprendió, ¿cuál es tu matriz y qué quieres omitir de tu matriz?
    2018-12-18 09: 35: 11Z
  3. Era mi error, usé la función regular y tuve que hacer explícitamente una declaración de retorno. Lo siento :)
    2018-12-18 09: 39: 43Z
  4. @ Dejan.S, edité la respuesta para algunos errores como tu error y agregas una sugerencia: si me votas, puedes votar ahora.
    2018-12-18 11: 50: 51Z

Nunca debes mutar tu matriz de tu matriz. Como esto va en contra del patrón de programación funcional. Lo que puedes hacer es crear una nueva matriz sin referencia.Busque la matriz de la que desea cambiar los datos utilizando el método 49610 de es6;

 filter

Supongamos que quieres eliminar

var myArray = [1,2,3,4,5,6];
de la matriz, simplemente puedes hacerlo de esta manera.  5

Esto le dará una nueva matriz sin el valor que desea eliminar. Así que el resultado será

 
myArray = myArray.filter(value => value !== 5);

Para una mayor comprensión, puede leer la documentación de MDN en Array.filter https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

    
19
2017-12-26 19: 32: 06Z

Un enfoque más moderno, ECMAScript 2015 (anteriormente conocido como Harmony o ES 6). Dado:

 
 [1,2,3,4,6]; // 5 has been removed from this array

Entonces:

 
const items = [1, 2, 3, 4];
const index = 2;

Rendimiento:

 
items.filter((x, i) => i !== index);

Puede usar Babel y un polyfill servicio para garantizar que este sea bien soportado en los navegadores.

    
18
2016-06-25 13: 01: 46Z
  1. Tenga en cuenta que
    [1, 2, 4]
    
    devuelve una nueva matriz, que no es exactamente lo mismo que eliminar el elemento de la misma matriz. El beneficio de este enfoque es que puede encadenar métodos de matriz juntos. por ejemplo: .filter
    2016-05-06 18: 58: 02Z
  2. Genial, si tengo 600k elementos en la matriz y quiero eliminar los primeros 50k, ¿te imaginas esa lentitud? Esto no es una solución, se necesita una función que solo elimine elementos y no devuelva nada.
    2016-05-30 15: 11: 17Z
  3. @ Seraph Para eso, es probable que desees utilizar [1,2,3].filter(n => n%2).map(n => n*n) === [ 1, 9 ] o splice.
    2016-05-31 22: 04: 28Z
  4. @ bjfletcher Eso es aún mejor, en proceso de eliminación, simplemente asigne elementos de 50K y tírelos en algún lugar. (con elementos de rebanada 550K, pero sin lanzarlos desde la ventana).
    2016-05-31 23: 06: 07Z
  5. Prefiero la respuesta de bjfletcher, que podría ser tan breve como slice. Además, el OP no estableció ningún requisito para un gran conjunto de datos.
    2016-08-27 01: 55: 25Z

Sé que ya hay muchas respuestas, pero muchas de ellas parecen complicar el problema. Esta es una forma simple y recursiva de eliminar todas las instancias de una clave: se llama a sí mismo hasta que no se encuentra el índice. Sí, solo funciona en los navegadores con items= items.filter(x=>x!=3), pero es simple y puede rellenarse fácilmente.

Función independiente

 indexOf

Método de prototipo

 
function removeAll(array, key){
    var index = array.indexOf(key);

    if(index === -1) return;

    array.splice(index, 1);
    removeAll(array,key);
}
    
16
2014-02-19 22: 20: 53Z
  1. Solo una nota, 1 advertencia con este método es la posibilidad de desbordamientos de pila. A menos que esté trabajando con matrices masivas, no debería tener un problema.
    2015-09-08 05: 57: 20Z

Puedes hacer un bucle hacia atrás para asegurarte de no arruinar los índices, si hay varias instancias del elemento.

 
Array.prototype.removeAll = function(key){
    var index = this.indexOf(key);

    if(index === -1) return;

    this.splice(index, 1);
    this.removeAll(key);
}

Demostración en vivo

    
15
2013-08-12 17: 56: 39Z

Tengo otra buena solución para eliminar de una matriz:

 
var myElement = "chocolate";
var myArray = ['chocolate', 'poptart', 'poptart', 'poptart', 'chocolate', 'poptart', 'poptart', 'chocolate'];

/* Important code */
for (var i = myArray.length - 1; i >= 0; i--) {
    if (myArray[i] == myElement) myArray.splice(i, 1);
}

https: //developer.mozilla. org /en-US /docs /Web /JavaScript /Reference /Global_Objects /Array /filter

    
15
2018-06-05 15: 51: 34Z

Tiene una matriz de 1 a 9 y desea eliminar el uso de 5 debajo del código.

 
var words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];

const result = words.filter(word => word.length > 6);

console.log(result);
// expected output: Array ["exuberant", "destruction", "present"]

Si desea valor múltiple, por ejemplo: - 1,7,8

 
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

var newNumberArray = numberArray.filter(m => {
  return m !== 5;
});

console.log("new Array, 5 removed", newNumberArray);

Si desea eliminar el valor de matriz en la matriz, por ejemplo: - [3,4,5]

 
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];

var newNumberArray = numberArray.filter(m => {
  return (m !== 1) && (m !== 7) && (m !== 8);
});

console.log("new Array, 5 removed", newNumberArray);

incluye navegador compatible es enlace

    
15
2018-08-21 04: 21: 54Z

Basándome en todas las respuestas que fueron principalmente correctas y teniendo en cuenta las mejores prácticas sugeridas (especialmente no utilizando Array.prototype directamente), se me ocurrió el siguiente código:

 
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];

var newNumberArray = numberArray.filter(m => {
    return !removebleArray.includes(m);
});

console.log("new Array, [3,4,5] removed", newNumberArray);

Al revisar la función anterior, a pesar de que funciona bien, me di cuenta de que podría haber alguna mejora en el rendimiento. También usar ES6 en lugar de ES5 es un enfoque mucho mejor. Para ello, este es el código mejorado:

 
function arrayWithout(arr, values) {
  var isArray = function(canBeArray) {
    if (Array.isArray) {
      return Array.isArray(canBeArray);
    }
    return Object.prototype.toString.call(canBeArray) === '[object Array]';
  };

  var excludedValues = (isArray(values)) ? values : [].slice.call(arguments, 1);
  var arrCopy = arr.slice(0);

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

  return arrCopy;
}

Cómo utilizar:

 
const arrayWithoutFastest = (() => {
  const isArray = canBeArray => ('isArray' in Array) 
    ? Array.isArray(canBeArray) 
    : Object.prototype.toString.call(canBeArray) === '[object Array]';

  let mapIncludes = (map, key) => map.has(key);
  let objectIncludes = (obj, key) => key in obj;
  let includes;

  function arrayWithoutFastest(arr, ...thisArgs) {
    let withoutValues = isArray(thisArgs[0]) ? thisArgs[0] : thisArgs;

    if (typeof Map !== 'undefined') {
      withoutValues = withoutValues.reduce((map, value) => map.set(value, value), new Map());
      includes = mapIncludes;
    } else {
      withoutValues = withoutValues.reduce((map, value) => { map[value] = value; return map; } , {}); 
      includes = objectIncludes;
    }

    const arrCopy = [];
    const length = arr.length;

    for (let i = 0; i < length; i++) {
      // If value is not in exclude list
      if (!includes(withoutValues, arr[i])) {
        arrCopy.push(arr[i]);
      }
    }

    return arrCopy;
  }

  return arrayWithoutFastest;  
})();

Actualmente estoy escribiendo una publicación de blog en la que he evaluado varias soluciones para Array sin problemas y comparé el tiempo que lleva correr. Actualizaré esta respuesta con el enlace una vez que termine esa publicación. Solo para hacerle saber, comparé lo anterior con el de lodash y, en caso de que el navegador admita

const arr = [1,2,3,4,5,"name", false];

arrayWithoutFastest(arr, 1); // will return array [2,3,4,5,"name", false]
arrayWithoutFastest(arr, 'name'); // will return [2,3,4,5, false]
arrayWithoutFastest(arr, false); // will return [2,3,4,5]
arrayWithoutFastest(arr,[1,2]); // will return [3,4,5,"name", false];
arrayWithoutFastest(arr, {bar: "foo"}); // will return the same array (new copy)
, ¡supera al de lodash! ¡Tenga en cuenta que no estoy usando Map o Array.prototype.indexOf para envolver los valores de exlcude en un Array.prototype.includes o Map hace que las consultas sean más rápidas!     
15
2018-11-19 23: 02: 58Z
Object
fuente colocada aquí