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

¿Hay una manera simple de eliminar un elemento específico de una matriz?

El equivalente de algo como -

array.remove(number);

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

9110
Walker 24 abr. 2011 a las 02:17

29 respuestas

La mejor respuesta

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

El método splice () cambia el contenido de una matriz al eliminar elementos existentes y / o agregar nuevos elementos.

const array = [2, 5, 9];

console.log(array);

const index = array.indexOf(5);
if (index > -1) {
  array.splice(index, 1);
}

// array = [2, 9]
console.log(array); 

El segundo parámetro de splice es la cantidad de elementos a eliminar. Tenga en cuenta que splice modifica la matriz en su lugar y devuelve una nueva matriz que contiene los elementos que se han eliminado.

11527
laurent 29 dic. 2019 a las 19:33

No sé cómo esperas que array.remove(int) se comporte. Hay tres posibilidades que se me ocurren que podría desear.

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

array.splice(i, 1);

Si desea eliminar cada elemento 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];
1218
Peter Mortensen 8 mar. 2020 a las 17:09

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

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 una combinación de slice y indexOf.

66
Peter Mortensen 1 sep. 2019 a las 22:16

Tiene de 1 a 9 en la matriz y desea eliminar 5. Use el siguiente código:

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 quieres múltiples valores. Ejemplo: - 1,7,8

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, 1,7 and 8 removed", newNumberArray);

Si desea eliminar un valor de matriz en una matriz. Ejemplo: [3,4,5]

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);

El navegador compatible incluye enlace.

20
Thilina Sampath 2 sep. 2019 a las 04:01
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)
141
Anthony 25 sep. 2017 a las 04:56

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 tenga necesidades diferentes que yo, por lo que puede modificarlo fácilmente para adaptarlo a ellas. Espero que esto ayude a alguien.

29
yckart 30 dic. 2014 a las 16:17

Quiero responder basado en ECMAScript 6. Supongamos que tiene una matriz como la siguiente:

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

Si desea eliminar en un índice especial como 2, escriba el siguiente código:

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

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

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

Sugerencia : utilice una función de flecha para la devolución de llamada del filtro a menos que obtenga una matriz vacía.

26
Peter Mortensen 1 sep. 2019 a las 22:59

La eliminación de un elemento / cadena particular de una matriz se puede hacer de una sola línea:

theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);

Dónde:

theArray : la matriz de la que desea eliminar algo en particular

stringToRemoveFromArray : la cadena que desea eliminar y 1 es la cantidad de elementos que desea eliminar.

NOTA : si "stringToRemoveFromArray" no se encuentra en su matriz, esto eliminará el último elemento de la matriz.

Siempre es una buena práctica verificar si el elemento existe primero en su matriz, antes de eliminarlo.

if (theArray.indexOf("stringToRemoveFromArray") >= 0){
   theArray.splice(theArray.indexOf("stringToRemoveFromArray"), 1);
}

Si tiene acceso a las nuevas versiones de Ecmascript en las computadoras de su cliente (ADVERTENCIA, puede no funcionar en estaciones más antiguas):

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

Donde '3' es el valor que desea eliminar de la matriz. La matriz se convertiría en: ['1','2','4','5','6']

30
Max Alexander Hanna 3 abr. 2020 a las 01:58

es6 & amp; sin mutación: (octubre de 2016)

const removeByIndex = (list, index) =>
      [
        ...list.slice(0, index),
        ...list.slice(index + 1)
      ];
         
output = removeByIndex([33,22,11,44],1) //=> [33,11,44]
      
console.log(output)
34
Dipen 10 feb. 2020 a las 07:37

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 desea extender un objeto global, puede hacer algo como lo siguiente:

// 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 estoy publicando esto es para advertir a los usuarios contra la implementación alternativa sugerida en los comentarios en 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;
};

Al principio parece funcionar bien, pero a través de un proceso doloroso descubrí que falla al intentar eliminar el penúltimo elemento de 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 he confirmado que la implementación original de John no tiene este problema.

64
magiccrafter 16 feb. 2015 a las 12:51

Aquí hay algunas formas de eliminar un elemento de una matriz usando JavaScript .

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

Si conoce el índice de un artículo

Supongamos 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 que sigue a la que eliminamos hasta el final de la matriz.

Si sabes 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 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 puede usar Babel y volver a compilar el código ES6 a ES5 para que sea más digerible para los navegadores antiguos, y aún así escribir JavaScript moderno en su código.

Eliminar múltiples elementos

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

Encontremos la solución más simple.

Por índice

Simplemente puede crear una función y eliminar elementos en 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)

Evite mutar la matriz original.

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

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

34
Flavio Copes 14 abr. 2019 a las 16:39

Puedes usar ES6. Por ejemplo, para eliminar el valor '3' en este caso:

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

Salida:

["1", "2", "4", "5", "6"]
62
darmis 1 oct. 2019 a las 22:13

Nunca debe mutar su matriz. Como esto va en contra del patrón de programación funcional. Puede crear una nueva matriz sin hacer referencia a la matriz de la que desea cambiar los datos utilizando el método ECMAScript 6 filter;

var myArray = [1, 2, 3, 4, 5, 6];

Supongamos que desea eliminar 5 de la matriz, simplemente puede hacerlo así:

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

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

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

Para una mejor comprensión, puede leer la documentación de MDN en Array.filter.

23
Peter Mortensen 1 sep. 2019 a las 22:41

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

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;
}

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 ese fin, este es el código mejorado:

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;  
})();

Cómo utilizar:

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)

Actualmente estoy escribiendo una publicación de blog en la que he comparado varias soluciones para Array sin problemas y comparado el tiempo que lleva ejecutar. Actualizaré esta respuesta con el enlace una vez que termine esa publicación. Solo para hacerle saber, he comparado lo anterior con lodash sin y en caso de que el navegador admita Map, ¡supera a lodash! Tenga en cuenta que no estoy usando Array.prototype.indexOf o Array.prototype.includes porque envolver los valores exlcude en un Map o Object hace que las consultas sean más rápidas.

18
Ardi 19 nov. 2018 a las 23:02

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.

P.ej. Si tiene un objeto con un campo Id y desea eliminar el objeto de una matriz:

this.array = this.array.filter(function(element, i) {
    return element.id !== idToRemove;
});
27
Anik Islam Abhi 10 nov. 2015 a las 04:20

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 ordenadas.


Esta esencia 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]
25
zykadelic 1 sep. 2017 a las 22:41

Si desea una nueva matriz con las posiciones eliminadas eliminadas, siempre puede eliminar el elemento específico y filtrar la matriz. Es posible que necesite una extensión del objeto de matriz para 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].

52
Peter Mortensen 1 sep. 2019 a las 20:30

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 (Internet Explorer 8, por ejemplo), 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 eliminan los elementos) y elimina el elemento si se encuentra. Funciona en todos los navegadores.

268
Peter Mortensen 1 sep. 2019 a las 21:54

Underscore.js se puede usar para resolver problemas con varios navegadores. Utiliza métodos de navegador integrados 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]
63
Peter Mortensen 21 may. 2017 a las 11:29

Actuación

Hoy (09-12-2019) realizo pruebas de rendimiento en macOS v10.13.6 (High Sierra) para las soluciones elegidas. Muestro delete (A), pero no lo uso en comparación con otros métodos, porque dejó un espacio vacío en la matriz.

Las conclusiones

  • la solución más rápida es array.splice (C) (excepto Safari para arreglos pequeños donde tiene la segunda vez)
  • para matrices grandes, array.slice+splice (H) es la solución inmutable más rápida para Firefox y Safari; Array.from (B) es más rápido en Chrome
  • las soluciones mutables suelen ser 1.5x-6x más rápidas que las inmutables
  • para tablas pequeñas en Safari, sorprendentemente la solución mutable (C) es más lenta que la solución inmutable (G)

Detalles

En las pruebas elimino el elemento medio de la matriz de diferentes maneras. Las soluciones A, C están en su lugar. Las soluciones B, D, E, F, G, H son inmutables.

Resultados para matriz con 10 elementos

Enter image description here

En Chrome, la array.splice (C) es la solución más rápida en el lugar. El array.filter (D) es la solución inmutable más rápida. El más lento es array.slice (F). Puede realizar la prueba en su máquina aquí.

Resultados para matriz con 1.000.000 de elementos

Enter image description here

En Chrome, la array.splice (C) es la solución más rápida en el lugar (la delete (C) es similar rápidamente, pero dejó un espacio vacío en la matriz (por lo que no funciona "completamente") eliminar')). El array.slice-splice (H) es la solución inmutable más rápida. El más lento es array.filter (D y E). Puede realizar la prueba en su máquina aquí.

var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (letter,array) => console.log(letter, array.join `,`);

function A(array) {
  var index = array.indexOf(5);
  delete array[index];
  log('A', array);
}

function B(array) {
  var index = array.indexOf(5);
  var arr = Array.from(array);
  arr.splice(index, 1)
  log('B', arr);
}

function C(array) {
  var index = array.indexOf(5);
  array.splice(index, 1);
  log('C', array);
}

function D(array) {
  var arr = array.filter(item => item !== 5)
  log('D', arr);
}

function E(array) {
  var index = array.indexOf(5);
  var arr = array.filter((item, i) => i !== index)
  log('E', arr);
}

function F(array) {
  var index = array.indexOf(5);
  var arr = array.slice(0, index).concat(array.slice(index + 1))
  log('F', arr);
}

function G(array) {
  var index = array.indexOf(5);
  var arr = [...array.slice(0, index), ...array.slice(index + 1)]
  log('G', arr);
}

function H(array) {
  var index = array.indexOf(5);
  var arr = array.slice(0);
  arr.splice(index, 1);
  log('H', arr);
}

A([...a]);
B([...a]);
C([...a]);
D([...a]);
E([...a]);
F([...a]);
G([...a]);
H([...a]);
This snippet only presents code used in performance tests - it does not perform tests itself.

Comparación para navegadores: Chrome v78.0.0, Safari v13.0.4 y Firefox v71.0.0

Enter image description here

20
Peter Mortensen 8 mar. 2020 a las 17:33

Mira este código. Funciona en todos los navegadores principales .

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

Llamar a esta función

remove_item(array,value);
43
Ekramul Hoque 24 may. 2014 a las 07:02

No es necesario 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);
  }
}

Use 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 (promedio de más de 10000 ejecuciones):

indexof es aproximadamente 10 veces más lento que move . Incluso si se mejora al eliminar la llamada a indexOf en empalme funciona 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
103
slosd 11 sep. 2015 a las 12:47

Esto proporciona 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;
    }
};
71
Peter Mortensen 1 sep. 2019 a las 22:18

Puede usar lodash _.pull (mutate array), _. pullAt (mutate array) o _.without (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']
41
Chun Yang 25 ago. 2015 a las 21:19

Sé que ya hay muchas respuestas, pero muchas de ellas parecen complicar demasiado el problema. Aquí hay 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 navegadores con indexOf, pero es simple y se puede rellenar fácilmente.

Función independiente

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

    if(index === -1) return;

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

Método de prototipo

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

    if(index === -1) return;

    this.splice(index, 1);
    this.removeAll(key);
}
18
wharding28 19 feb. 2014 a las 22:20

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

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

Entonces:

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

Flexible:

[1, 2, 4]

Puede utilizar Babel y un servicio polyfill para garantizar que esto sea compatible con todos los navegadores.

22
Peter Mortensen 25 jun. 2016 a las 13:01

Hay dos enfoques principales:

  1. empalme () : 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 matrices. Es mejor usar splice para las matrices.

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 de longitud.

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

Si se ve obligado a usar delete por alguna razón, debe usar for each se repite cuando necesita recorrer las matrices. De hecho, siempre evite usar bucles indexados for, si es posible. De esa forma, el código sería más robusto y menos propenso a problemas con los índices.

166
Peter Mortensen 1 sep. 2019 a las 21:51

OK, por ejemplo, tiene la matriz a continuación:

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

Y queremos eliminar el número 4. Simplemente puede usar el siguiente código:

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

Si está reutilizando esta función, escriba una función reutilizable que se adjuntará a la función de matriz native 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 su lugar con unos pocos [5] s en la matriz?

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

Necesitamos un bucle para verificarlos todos, pero una forma más fácil y eficiente es usar funciones de JavaScript incorporadas, 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 hacer esto, como Lodash o Underscore. Para obtener más información, mire lodash _.pull, _.pullAt o _.without.

34
Peter Mortensen 1 sep. 2019 a las 22:33

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

Si desea un espacio vacío, eliminar está bien:

delete array[index];

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

array.splice(index, 1);

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

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

En caso de que desee hacerlo en algún orden, puede 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 obtenerlos todos) . array.indexOf(item) devuelve el índice o -1 si no se encuentra.

440
Peter Mortensen 1 sep. 2019 a las 20:29