it-swarm-es.com

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

Tengo una matriz 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 core JavaScript - no marcos están permitidos.

7380
Walker

Encuentre la index del elemento de la 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 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. Tenga en cuenta que splice modifica la matriz en su lugar y devuelve una nueva matriz que contiene los elementos que se han eliminado.

9908
Tom Wadley

No sé cómo esperas que array.remove(int) se comporte. 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];
1011
Peter Olson

Editado el 2016 octubre

  • Hazlo simple, intuitivo y explícito ( https://en.wikipedia.org/wiki/Occam%27s_razor )
  • Hazlo inmutable (la matriz original permanece sin cambios)
  • Hágalo con las funciones estándar de JS, si su navegador no las admite - use polyfill

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 filtro de polietileno de Mozilla .

Eliminando artículo (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 artículo (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 ]

IMPORTANT ES2015 "() => {}" la sintaxis de la función de flecha no se admite en IE en absoluto, 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 múltiples 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 se admite en IE en absoluto, 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

Eliminación de varios elementos (vanguardista experimental JavaScript ES2018?)

// 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ébalo tú mismo en BabelJS :)

Referencia

831
Ujeenator

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

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

delete array[ index ];

Si no lo hace, debería usar el método 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 quiera hacerlo en algún orden, puede usar array.pop() para la última o array.shift() para la primera (y ambos también devuelven el valor del elemento).

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

383
xavierm02

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.

251
Ben Lesh

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 arreglos. Es mejor usar splice para los arreglos.

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

También puede 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 loops cuando necesite recorrer los arrays. 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.

142
Sasa
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)

118
Zirak

No es necesario utilizar 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 matriz con 1000 elementos (promedio de más de 10000 ejecuciones):

indexof es aproximadamente 10x más lento que mover . Incluso si se mejoró eliminando la llamada a indexOf en empalme 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
87
slosd

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

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

Parece funcionar 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.

56
Roger

Underscore.js puede usarse para resolver problemas con múltiples 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]
54
vatsal

Puedes hacerlo fácilmente con filter method:

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 e indexOf

53
Salvador Dali

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 array 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 hace 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';}));

Debe mostrar [1, 2, 3, 4, 6]

42
Loupax

Puedes usar ES6. 

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

Salida: 

["1", "2", "4", "5", "6"]
38
rajat44

Echa un vistazo a este código. Funciona en todos 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);
35
Ekramul Hoque

Puede usar lodash _.pull (mutate array), _.pullAt (mutate array) o _.without (no mute array), 

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']
33
Chun Yang

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 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 unos pocos [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 utiliza el 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, consulte lodash _.pull, _.pullAt o _.without.

32
Alireza

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

Entonces, 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 a las que yo, por lo que puede modificarla fácilmente para que se adapte a ellas. Espero que esto ayude a alguien.

27
sofiax

ES6 y 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]
24
Abdennour TOUMI

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 Gist aquí resolverá su problema y también elimina todas las apariciones del argumento en lugar de solo 1 (o un valor específico).

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]
22
zykadelic

Si tienes objetos complejos en la matriz puedes 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 de identificación y desea que se elimine el objeto de una matriz:

this.array = this.array.filter(function(element, i) {
    return element.id !== idToRemove;
});
21
flurdy

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

Todo el método descrito no muta la matriz original , y en su lugar crea una nueva.

Si conoces el índice de un elemento.

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-1).concat(items.slice(i, 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 usar 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 puede usar Babel y transferir el código ES6 de vuelta a ES5 para hacerlo más digerible para los navegadores antiguos, pero escribir JavaScript moderno en su código.

Eliminar varios elementos

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

Encontremos la solución más sencilla.

Por índice

Puede 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() (no debe confundirse con slice()) muta la matriz original, y debe evitarse.

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

20
Flavio Copes

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

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

Supongamos que desea eliminar 5 de la matriz, simplemente puede hacerlo de esta manera.

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

Esto le dará una nueva matriz sin el valor que quería eliminar. Entonces el resultado será

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

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
Adeel Imran

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 usar Babel y un servicio polyfill para asegurarse de que esto sea compatible con todos los navegadores.

18
bjfletcher

Sé que ya hay muchas respuestas, pero muchas de ellas parecen complicar el problema en exceso. 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 indexOf, pero es simple y puede rellenarse fácilmente.

Función autónoma

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);
}
16
wharding28

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

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"]

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

15
Aram Grigoryan

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

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

Demo en vivo

15
Jeff Noel

Sobre la base de todas las respuestas que fueron principalmente correctas y teniendo en cuenta las mejores prácticas sugeridas (especialmente no usar 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 ello, 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 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 Map, ¡supera al de lodash! Tenga en cuenta que no estoy usando Array.prototype.indexOf o Array.prototype.includes como envolviendo los valores de exlcude en una Map o Object hace que las consultas sean más rápidas.

15
Ardi

Tiene una matriz de 1 a 9 y desea eliminar el uso de 5 debajo del 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 valor múltiple ex: - 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, 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 removebleArray = [3,4,5];

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

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

incluye navegador compatible es enlace

14
Thilina Sampath
  Array.prototype.removeItem = function(a) {
            for (i = 0; i < this.length; i++) {
                if (this[i] == a) {
                    for (i2 = i; i2 < this.length - 1; i2++) {
                        this[i2] = this[i2 + 1];
                    }
                    this.length = this.length - 1
                    return;
                }
            }
        }

    var recentMovies = ['Iron Man', 'Batman', 'Superman', 'Spiderman'];
    recentMovies.removeItem('Superman');
13

Eliminar por índice

Función que devuelve una copia de la matriz sin el elemento en el índice.

/**
* removeByIndex
* @param {Array} array
* @param {Number} index
*/
function removeByIndex(array, index){
    return array.filter(function(elem, _index){
        return index != _index;
    });
}
l = [1,3,4,5,6,7];
console.log(removeByIndex(l, 1));

$> [ 1, 4, 5, 6, 7 ]

Eliminar por valor

Función que devuelve una copia de la matriz sin el valor.

/**
* removeByValue
* @param {Array} array
* @param {Number} value
*/
function removeByValue(array, value){
    return array.filter(function(elem, _index){
        return value != elem;
    });
}
l = [1,3,4,5,6,7];
console.log(removeByValue(l, 5));

$> [ 1, 3, 4, 6, 7]
13
nsantana

Quiero responder basado enES6. Supongamos que tienes una matriz como la siguiente:

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

Si desea eliminar 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 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.

11
AmerllicA

Crear nueva matriz:

var my_array = new Array();

Añadir elementos a esta matriz:

my_array.Push("element1");

La función indexOf (devuelve el índice o -1 cuando no se encuentra):

var indexOf = function(needle) 
{
    if(typeof Array.prototype.indexOf === 'function') // newer browsers
    {
        indexOf = Array.prototype.indexOf;
    } 
    else // older browsers
    {
        indexOf = function(needle) 
        {
            var index = -1;

            for(var i = 0; i < this.length; i++) 
            {
                if(this[i] === needle) 
                {
                    index = i;
                    break;
                }
            }
            return index;
        };
    }

    return indexOf.call(this, needle);
};

Verifique el índice de este elemento (probado con Firefox e IE8 +):

var index = indexOf.call(my_array, "element1");

Eliminar 1 elemento ubicado en el índice de la matriz

my_array.splice(index, 1);
11
Enrico

También corrí en la situación en la que tuve que eliminar un elemento de Array. .indexOf no estaba funcionando en IE* así que compartí mi solución de trabajo jQuery.inArray().

var index = jQuery.inArray(val,arr);
if (index > -1) {
    arr.splice(index, 1);
    //console.log(arr);
}
10
NullPointer

2017-05-08

La mayoría de las respuestas proporcionadas funcionan para una comparación estricta, lo que significa que ambos objetos hacen referencia al mismo objeto exacto en la memoria (o son tipos primitivos), pero a menudo desea eliminar un objeto no primitivo de una matriz que tiene un cierto valor. Por ejemplo, si realiza una llamada a un servidor y desea verificar un objeto recuperado contra un objeto local.

const a = {'field': 2} // Non-primitive object
const b = {'field': 2} // Non-primitive object with same value
const c = a            // Non-primitive object that reference the same object as "a"

assert(a !== b) // Don't reference the same item, but have same value
assert(a === c) // Do reference the same item, and have same value (naturally)

//Note: there are many alternative implementations for valuesAreEqual
function valuesAreEqual (x, y) {
   return  JSON.stringify(x) === JSON.stringify(y)
}


//filter will delete false values
//Thus, we want to return "false" if the item
// we want to delete is equal to the item in the array
function removeFromArray(arr, toDelete){
    return arr.filter(target => {return !valuesAreEqual(toDelete, target)})
}

const exampleArray = [a, b, b, c, a, {'field': 2}, {'field': 90}];
const resultArray = removeFromArray(exampleArray, a);

//resultArray = [{'field':90}]

Hay implementaciones alternativas/más rápidas para valuesAreEqual, pero esto hace el trabajo. También puede usar un comparador personalizado si tiene un campo específico para verificar (por ejemplo, algunos UUID recuperados frente a un UUID local).

También tenga en cuenta que esta es una operación funcional, lo que significa que no muta la matriz original.

9
Aidan Hoolachan

Creo que muchas de las instrucciones de JavaScript no están bien pensadas para la programación funcional. Splice devuelve el elemento eliminado donde la mayor parte del tiempo necesita la matriz reducida. Esto es malo.

Imagina que estás haciendo una llamada recursiva y tienes que pasar una matriz con un elemento menos, probablemente sin el elemento indexado actual. O imagine que está haciendo otra llamada recursiva y tiene que pasar una matriz con un elemento empujado.

En ninguno de estos casos puede hacer myRecursiveFunction(myArr.Push(c)) o myRecursiveFunction(myArr.splice(i,1)). El primer idiota pasará de hecho la longitud de la matriz y el segundo idiota pasará el elemento eliminado como parámetro.

Entonces, qué hago de hecho ... Para eliminar un elemento de matriz y pasar el resultado a una función como parámetro al mismo tiempo, hago lo siguiente

myRecursiveFunction(myArr.slice(0,i).concat(a.slice(i+1)))

Cuando se trata de Push, eso es más tonto ... Me gusta,

myRecursiveFunction((myArr.Push(c),myArr))

Creo que en un lenguaje funcional adecuado, un método que mute el objeto al que se llama debe devolver una referencia al mismo objeto como resultado.

9
Redu

En CoffeeScript :

my_array.splice(idx, 1) for ele, idx in my_array when ele is this_value
8

Utilice jQuery InArray:

A = [1, 2, 3, 4, 5, 6];
A.splice($.inArray(3, A), 1);
//It will return A=[1, 2, 4, 5, 6]`   

Nota: inArray devolverá -1, si el elemento no fue encontrado.

7
Do Hoa Vinh

JavaScript de vainilla (ES5.1) - en lugar edición

Soporte del navegador: Internet Explorer 9 o posterior ( Soporte detallado del navegador )

/**
 * Removes all occurences of the item from the array.
 *
 * Modifies the array “in place”, i.e. the array passed as an argument
 * is modified as opposed to creating a new array. Also returns the modified
 * array for your convenience.
 */
function removeInPlace(array, item) {
    var foundIndex, fromIndex;

    // Look for the item (the item can have multiple indices)
    fromIndex = array.length - 1;
    foundIndex = array.lastIndexOf(item, fromIndex);

    while (foundIndex !== -1) {
        // Remove the item (in place)
        array.splice(foundIndex, 1);

        // Bookkeeping
        fromIndex = foundIndex - 1;
        foundIndex = array.lastIndexOf(item, fromIndex);
    }

    // Return the modified array
    return array;
}

JavaScript de vainilla (ES5.1) - inmutable edición

Soporte del navegador: igual que Vanilla JavaScript en edición de lugar

/**
 * Removes all occurences of the item from the array.
 *
 * Returns a new array with all the items of the original array except
 * the specified item.
 */
function remove(array, item) {
    var arrayCopy;

    arrayCopy = array.slice();

    return removeInPlace(arrayCopy, item);
}

Vanilla ES6 - inmutable edición

Soporte del navegador: Chrome 46, Edge 12, Firefox 16, Opera 37, Safari 8 ( soporte detallado del navegador )

/**
 * Removes all occurences of the item from the array.
 *
 * Returns a new array with all the items of the original array except
 * the specified item.
 */
function remove(array, item) {
    // Copy the array
    array = [...array];

    // Look for the item (the item can have multiple indices)
    let fromIndex = array.length - 1;
    let foundIndex = array.lastIndexOf(item, fromIndex);

    while (foundIndex !== -1) {
        // Remove the item by generating a new array without it
        array = [
            ...array.slice(0, foundIndex),
            ...array.slice(foundIndex + 1),
        ];

        // Bookkeeping
        fromIndex = foundIndex - 1;
        foundIndex = array.lastIndexOf(item, fromIndex)
    }

    // Return the new array
    return array;
}
[2,3,5].filter(i => ![5].includes(i))

Elimine el elemento en el índice i, sin mutar la matriz original:

/**
* removeElement
* @param {Array} array
* @param {Number} index
*/
function removeElement(array, index) {
   return Array.from(array).splice(index, 1);
}

// Another way is
function removeElement(array, index) {
   return array.slice(0).splice(index, 1);
}
6
alejandro

Me gusta esta versión de splice, eliminando un elemento por su valor usando $.inArray:

$(document).ready(function(){
    var arr = ["C#","Ruby","PHP","C","C++"];
    var itemtoRemove = "PHP";
    arr.splice($.inArray(itemtoRemove, arr),1);
});
6
mboeckle

Puede iterar sobre cada array- elemento y splice si existe en su array.

function destroy(arr, val) {
    for (var i = 0; i < arr.length; i++) if (arr[i] === val) arr.splice(i, 1);
    return arr;
}
6
yckart

Acabo de crear un polyfill en el Array.prototype a través de Object.defineProperty para eliminar un elemento deseado en una matriz sin que se produzcan errores al iterar sobre él más tarde a través de for .. in ..

if (!Array.prototype.remove) {
  // Object.definedProperty is used here to avoid problems when iterating with "for .. in .." in Arrays
  // https://stackoverflow.com/questions/948358/adding-custom-functions-into-array-prototype
  Object.defineProperty(Array.prototype, 'remove', {
    value: function () {
      if (this == null) {
        throw new TypeError('Array.prototype.remove called on null or undefined')
      }

      for (var i = 0; i < arguments.length; i++) {
        if (typeof arguments[i] === 'object') {
          if (Object.keys(arguments[i]).length > 1) {
            throw new Error('This method does not support more than one key:value pair per object on the arguments')
          }
          var keyToCompare = Object.keys(arguments[i])[0]

          for (var j = 0; j < this.length; j++) {
            if (this[j][keyToCompare] === arguments[i][keyToCompare]) {
              this.splice(j, 1)
              break
            }
          }
        } else {
          var index = this.indexOf(arguments[i])
          if (index !== -1) {
            this.splice(index, 1)
          }
        }
      }
      return this
    }
  })
} else {
  var errorMessage = 'DANGER ALERT! Array.prototype.remove has already been defined on this browser. '
  errorMessage += 'This may lead to unwanted results when remove() is executed.'
  console.log(errorMessage)
}

Eliminando un valor entero

var a = [1, 2, 3]
a.remove(2)
a // Output => [1, 3]

Eliminando un valor de cadena

var a = ['a', 'ab', 'abc']
a.remove('abc')
a // Output => ['a', 'ab']

Eliminando un valor booleano

var a = [true, false, true]
a.remove(false)
a // Output => [true, true]

También es posible eliminar un objeto dentro de la matriz a través de este método Array.prototype.remove. Solo debe especificar el key => value de la Object que desea eliminar.

Eliminando un valor de objeto

var a = [{a: 1, b: 2}, {a: 2, b: 2}, {a: 3, b: 2}]
a.remove({a: 1})
a // Output => [{a: 2, b: 2}, {a: 3, b: 2}]
5
Victor

Hice una extensión bastante eficiente a la matriz de JavaScript base:

Array.prototype.drop = function(k) {
  var valueIndex = this.indexOf(k);
  while(valueIndex > -1) {
    this.removeAt(valueIndex);
    valueIndex = this.indexOf(k);
  }
};
5
Shawn Deprey

Con mi solución, puede eliminar uno o más de un elemento de una matriz gracias a JavaScript puro. No hay necesidad de otra biblioteca de JavaScript.

var myArray = [1,2,3,4,5]; // First array

var removeItem = function(array,value) {  // My clear function
    if(Array.isArray(value)) {  // For multi remove
        for(var i = array.length - 1; i >= 0; i--) {
            for(var j = value.length - 1; j >= 0; j--) {
                if(array[i] === value[j]) {
                    array.splice(i, 1);
                };
            }
        }
    }
    else { // For single remove
        for(var i = array.length - 1; i >= 0; i--) {
            if(array[i] === value) {
                array.splice(i, 1);
            }
        }
    }
}

removeItem(myArray,[1,4]); // myArray will be [2,3,5]
5
Kamuran Sönecek

Elimine un valor, utilizando comparación suelta, sin mutar la matriz original, ES6

/**
 * Removes one instance of `value` from `array`, without mutating the original array. Uses loose comparison.
 * 
 * @param {Array} array Array to remove value from
 * @param {*} value Value to remove
 * @returns {Array} Array with `value` removed
 */
export function arrayRemove(array, value) {
    for(let i=0; i<array.length; ++i) {
        if(array[i] == value) {
            let copy = [...array];
            copy.splice(i, 1);
            return copy;
        }
    }
    return array;
}
4
mpen

Otra respuesta más, para mí, cuanto más simple, mejor, y como estamos en 2018 (cerca de 2019), le entrego este (cerca) un trazador de líneas para responder a la pregunta original:

Array.prototype.remove = function (value) { 
    return this.filter(f => f != value) 
}

Lo útil es que puedes usarlo en una expresión de curry como:

[1,2,3].remove(2).sort()

4
Sebastien H.

Si bien la mayoría de las respuestas anteriores responden a la pregunta, no está lo suficientemente claro por qué no se ha utilizado el método slice(). Sí, filter() cumple con los criterios de inmutabilidad, pero ¿qué hay de hacer el siguiente equivalente más corto:

const myArray = [1,2,3,4];

Y ahora digamos que debemos eliminar el segundo elemento de la matriz, simplemente podemos hacer: const newArray = myArray.slice(0,1).concat(myArray.slice(2,4));// [1,3,4]

Esta forma de eliminar un elemento de una matriz se recomienda mucho hoy en la comunidad debido a su naturaleza simple e inmutable. En general, deben evitarse los métodos que causan mutación. Por ejemplo, se recomienda que reemplace Push() con concat() y splice() con slice() 

4
Stelios Voskos

Utilice jQuery.grep () :

var y = [1, 2, 3, 9, 4]
var removeItem = 9;

y = jQuery.grep(y, function(value) {
  return value != removeItem;
});
console.log(y)
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.12.2/jquery.min.js"></script>

4
Mahendra Kulkarni

La eliminación de un elemento/cadena en particular de una matriz se puede hacer en una línea: Todavía creo que esta es la línea más elegante que puede obtener para este tipo de problema: 

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

donde 'theArray' es la matriz de la que desea eliminar algo en particular.

4

Publique mi código que elimina un elemento de matriz en su lugar y reduzca la longitud de la matriz también.

function removeElement(idx, arr) {
    // check the index value
    if (idx < 0 || idx >= arr.length) {
        return;
    }
    // shift the elements
    for (var i = idx; i > 0; --i) {
        arr[i] = arr[i - 1];
    }
    // remove the first element in array
    arr.shift();
}
3
hailong

Hay muchas respuestas fantásticas aquí, pero para mí, lo que funcionó más simplemente no fue eliminar mi elemento de la matriz por completo, sino simplemente establecer su valor en nulo. Esto funciona para la mayoría de los casos que tengo, y es una buena solución ya que usaré la variable más adelante y no quiero que desaparezca, solo está vacía por ahora. Además, este enfoque es totalmente compatible con varios navegadores.

array.key = null;
3
rncrtr

¿Eliminar la última aparición o todas las apariciones, o la primera aparición? 

var array = [2, 5, 9, 5];

// Remove last occurrence (or all occurrences)
for (var i = array.length; i--;) {
  if (array[i] === 5) {
     array.splice(i, 1);
     break; // Remove this line to remove all occurrences
  }
}

o

var array = [2, 5, 9, 5];

// Remove first occurrence
for (var i = 0; array.length; i++) {
  if (array[i] === 5) {
     array.splice(i, 1);
     break; // Do not remove this line
  }
}
3
MEC

Para cualquier persona que quiera replicar un método que devolverá una nueva matriz a la que se han eliminado números duplicados o cadenas, esto se ha juntado de las respuestas existentes:

function uniq(array) {
  var len = array.length;
  var dupFree = [];
  var tempObj = {};

  for (var i = 0; i < len; i++) {
    tempObj[array[i]] = 0;
  }

  console.log(tempObj);

  for (var i in tempObj) {
    var element = i;
    if (i.match(/\d/)) {
      element = Number(i);
    }
    dupFree.Push(element);
  }

  return dupFree;
}
3
cjjenkinson

Hice una función 

function pop(valuetoremove, myarray) {
var indexofmyvalue = myarray.indexOf(valuetoremove);
myarray.splice(indexofmyvalue, 1);
}

Y usado así.

pop(valuetoremove,myarray);

¡Aclamaciones!

3
Ali Akram

Una implementación muy ingenua sería la siguiente:

Array.prototype.remove = function(data) {
    const dataIdx = this.indexOf(data)
    if(dataIdx >= 0) {
        this.splice(dataIdx ,1);
    }
    return this.length;
}

let a = [1,2,3];
// this will change arr a to [1, 3]
a.remove(2);

Devuelvo la longitud de la matriz desde la función para cumplir con los otros métodos como Array.prototype.Push().

3
Gaurang Patel

Yo mismo tuve este problema (en una situación en la que era aceptable reemplazar la matriz) y lo resolví con un simple:

var filteredItems = this.items.filter(function (i) {
    return i !== item;
});

Para darle al fragmento de arriba un poco de contexto:

self.thingWithItems = {
        items: [],
        removeItem: function (item) {
            var filteredItems = this.items.filter(function (i) {
                return i !== item;
            });

            this.items = filteredItems;
        }
    };

Esta solución debería funcionar con elementos de referencia y de valor. Todo depende de si necesita mantener una referencia a la matriz original en cuanto a si esta solución es aplicable. 

2
Phil

A menudo es mejor crear una nueva matriz con la función de filtro.

const array = [1,2,3,4];
array = array.filter(i => i !== 4); // [1,2,3]

Esto también mejora la legibilidad imho. No soy un fanático de la rebanada, aunque sé que a veces debes intentarlo.

2
codepleb
var array = [2, 5, 9];
array.splice(array.findIndex(x => x==5), 1);

Usando Array.findindex, podemos reducir el número de líneas de código.

developer.mozilla.org

2
sujithklr93
var index,
    input = [1,2,3],
    indexToRemove = 1;
    integers = [];

for (index in input) {
    if (input.hasOwnProperty(index)) {
        if (index !== indexToRemove) {
            integers.Push(result); 
        }
    }
}
input = integers;

Esta solución tomará una serie de entradas y buscará en la entrada el valor que se eliminará. Esto recorrerá la totalidad de la matriz de entrada y el resultado será una segunda matriz de enteros a los que se eliminó el índice específico. La matriz de enteros se vuelve a copiar en la matriz de entrada. 

2
penguin

Su pregunta no indicó si el orden o los valores distintos son un requisito.

Si no le importa el orden y no tendrá el mismo valor en el contenedor más de una vez, use un Set. Será mucho más rápido, y más sucinto. 

var aSet = new Set();

aSet.add(1);
aSet.add(2);
aSet.add(3);

aSet.delete(2);
2
Steven Spungin

Eliminando el valor con índice y empalme!

function removeArrValue(arr,value) {
    var index = arr.indexOf(value);
    if (index > -1) {
        arr.splice(index, 1);
    }
    return arr;
}
2
Nejc Lepen

eliminar elemento del último 

arrName.pop();

eliminar elemento de la primera 

arrName.shift();

borrar del medio

arrName.splice(starting index,number of element you wnt to delete);

Ex: arrName.splice(1,1);

borrar un elemento del último

arrName.splice(-1);

Eliminar utilizando el número de índice de matriz

 delete arrName[1];
2
Srikrushna Pal

Qué vergüenza tienes una matriz de enteros, no un objeto donde las claves son equivalentes de cadena de estos enteros.

He revisado muchas de estas respuestas y todas parecen usar la "fuerza bruta" por lo que puedo ver. No he examinado a todos, disculpas si esto no es así. Para una matriz más bien pequeña, esto está bien, pero ¿qué sucede si tiene miles de enteros?

Corríjame si me equivoco, pero ¿no podemos asumir que en un mapa key => value, del tipo que es un objeto JS, se puede suponer que el mecanismo de recuperación de clave está altamente diseñado y optimizado? (NB: si algún súper experto me dice que este no es el caso, puedo sugerir que use el clase de mapa de ES6 en su lugar, lo que seguramente será).

Solo estoy sugiriendo que, en ciertas circunstancias, la mejor solución podría ser convertir su matriz en un objeto ... el problema es, por supuesto, que podría tener valores enteros que se repiten. Sugiero colocarlos en grupos como la parte "valor" de las entradas key => value. (NB: si está seguro de que no tiene ningún elemento de la matriz que se repite, esto puede ser mucho más sencillo: valore los valores "igual que", y simplemente vaya Object.values(...) para recuperar su matriz modificada).

Para que pudieras hacer:

const arr = [ 1, 2, 55, 3, 2, 4, 55 ];
const f =   function( acc, val, currIndex ){ 
    // not seen this val before: make bucket... NB although val's typeof is 'number'
    // there is seamless equivalence between the object key (always string)
    // and this variable val 
    ! ( val in acc ) ? acc[ val ] = []: 0;
    // drop another array index in the bucket
    acc[ val ].Push( currIndex );
    return acc; 
}
const myIntsMapObj = arr.reduce( f, {});

console.log( myIntsMapObj );

salida:

Objeto [<1 ranura vacía>, Array 1 , Array [2], Array 1 , Array 1 , <5 Ranuras vacías>, 46 más ...]

entonces es fácil borrar todos los números 55

delete myIntsMapObj[ 55 ]; // again, although keys are strings this works

No tiene que eliminarlos todos: los valores de índice se insertan en sus grupos en orden de aparición, por lo que (por ejemplo):

myIntsMapObj[ 55 ].shift(); // and
myIntsMapObj[ 55 ].pop(); 

borrará la primera y última ocurrencia respectivamente. Puede contar la frecuencia de ocurrencia fácilmente, reemplazar todos los 55 por 3 al transferir el contenido de un grupo a otro, etc.

... recuperar su matriz int modificada está ligeramente involucrado, pero cada grupo contiene el índice (en la matriz original) del valor representado por la clave (cadena). Cada uno de estos valores de depósito también es único: de modo que los convierta en claves en un nuevo objeto, con el entero (real) de la "clave de cadena de entero" como valor ... luego ordene las claves y haga Object.values( ... ).

Esto suena muy complicado y requiere mucho tiempo ... pero obviamente todo depende de las circunstancias y el uso deseado. Tengo entendido que todas las versiones y contextos de JS operan solo en un hilo, y el hilo no se "suelta", por lo que podría haber una congestión horrible con un método de "fuerza bruta": causado no tanto por las operaciones indexOf , pero múltiples repetidas slice/splice ops.

Addendum
Si es seguro esto es demasiada ingeniería para su caso de uso, seguramente el enfoque más simple de "fuerza bruta" es

const arr = [ 1, 2, 3, 66, 8, 2, 3, 2 ];
const newArray = arr.filter( number => number !== 3 );
console.log( newArray )

(sí, otras respuestas han detectado Array.prototype.filter...)

2
mike rodent

El siguiente método eliminará todas las entradas de un valor dado de una matriz sin crear una nueva matriz y con solo una iteración que es superfast . Y funciona en el antiguo Internet Explorer 5.5 browser:

function removeFromArray(arr, removeValue) {
  for (var i = 0, k = 0, len = arr.length >>> 0; i < len; i++) {
    if (k > 0)
      arr[i - k] = arr[i];

    if (arr[i] === removeValue)
      k++;
  }

  for (; k--;)
    arr.pop();
}

var a = [0, 1, 0, 2, 0, 3];

document.getElementById('code').innerHTML =
  'Initial array [' + a.join(', ') + ']';
//Initial array [0, 1, 0, 2, 0, 3]

removeFromArray(a, 0);

document.getElementById('code').innerHTML +=
  '<br>Resulting array [' + a.join(', ') + ']';
//Resulting array [1, 2, 3]
<code id="code"></code>

2
Eugene Tiurin

Para eliminar un elemento en particular o elementos posteriores, Array.splice () method funciona bien. El método splice () cambia el contenido de una matriz eliminando o reemplazando elementos existentes y/o agregando nuevos elementos y devuelve los elementos eliminados.

Sintaxis: array.splice (index, deleteCount, item1, ....., itemX)

Aquí index es obligatorio y los argumentos de resto son opcionales.

Por ejemplo:

let arr = [1, 2, 3, 4, 5, 6];
arr.splice(2,1);
console.log(arr);
// [1, 2, 4, 5, 6]

Nota: Array.splice () method puede usarse si conoce el índice del elemento que desea eliminar. Pero podemos tener algunos casos más como se menciona a continuación-

  1. En caso de que desee eliminar el último elemento, puede usar Array.pop ()

  2. En caso de que desee eliminar solo el primer elemento, puede usar Array.shift ()

  3. Si conoce el elemento solo pero no la posición (o el índice) del elemento y desea eliminar todos los elementos coincidentes utilizando Array.filter () method:

    let arr = [1, 2, 1, 3, 4, 1, 5, 1];
    
    let newArr = arr.filter(function(val){
        return val !== 1;
     });
     //newArr => [2, 3, 4, 5]
    

O usando el método splice () como

let arr = [1, 11, 2, 11, 3, 4, 5, 11, 6, 11];
    for( let i = 0; i < arr.length-1; i++){
       if ( arr[i] === 11) {
         arr.splice(i, 1); 
       }
    }
    console.log(arr);
    // [1, 2, 3, 4, 5, 6]

O Supongamos que queremos eliminar del del Array arr:

let arr = [1, 2, 3, 4, 5, 6];
let del = 4;
if(arr.indexOf(4) >= 0) {
arr.splice(arr.indexOf(4), 1)
}

OR

let del = 4;
for(var i = arr.length - 1; i >= 0; i--) {
    if(arr[i] === del) {
       arr.splice(i, 1);
    }
}
  1. Si conoce el elemento solo pero no la posición (o índice) del elemento, y desea eliminar solo el primer elemento coincidente utilizando el método splice ():

    let arr = [1, 11, 2, 11, 3, 4, 5, 11, 6, 11];
    
    for( let i = 0; i < arr.length-1; i++){
      if ( arr[i] === 11) {
        arr.splice(i, 1);
        break;
      }
    }
    console.log(arr);
    // [1, 11, 2, 11, 3, 4, 5, 11, 6, 11]
    
1
Chang

Si debe admitir versiones anteriores de Internet Explorer, recomiendo usar el siguiente polyfill (nota: esto es no marco). Es un reemplazo 100% compatible con versiones anteriores de todos los métodos de arreglos modernos (JavaScript 1.8.5/ECMAScript 5 Array Extras) que funciona para Internet Explorer 6+, Firefox 1.5+, Chrome, Safari y Opera.

https://github.com/plusdude/array-generics

1
Matt Brock

Defina un método llamado remove () en objetos de matriz utilizando la función de prototización de JavaScript.

Utilice splice () method para cumplir con sus requisitos.

Por favor, eche un vistazo al siguiente código.

Array.prototype.remove = function(item) {
    // index will have -1 if item does not exist
    // else it will have the index of 1st item found in array
    var index = this.indexOf(item); 

    if (index > -1) {
        // splice() method is used to add/remove items(s) in array
        this.splice(index, 1); 
    }

    return index;
}


var arr = [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];

// Printing array
// [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];
console.log(arr)

// Removing 67 (getting its index i.e. 2)
console.log("Removing 67")
var index = arr.remove(67)

if (index > 0){
    console.log("Item 67 found at ", index)
} else {
    console.log("Item 67 does not exist in array")
}

// Printing updated array
// [ 11, 22, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4];
console.log(arr)

// ............... Output ................................
// [ 11, 22, 67, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4 ]
// Removing 67
// Item 67 found at  2
// [ 11, 22, 45, 61, 89, 34, 12, 7, 8, 3, -1, -4 ]

Nota: A continuación se muestra el código de ejemplo completo ejecutado en Node.js REPL que describe el uso de Push (), pop (), shift (), unshift () y splice () Métodos.

> // Defining an array
undefined
> var arr = [12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34];
undefined
> // Getting length of array
undefined
> arr.length;
16
> // Adding 1 more item at the end i.e. pushing an item
undefined
> arr.Push(55);
17
> arr
[ 12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34, 55 ]
> // Popping item from array (i.e. from end)
undefined
> arr.pop()
55
> arr
[ 12, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> // Remove item from beginning
undefined
> arr.shift()
12
> arr
[ 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> // Add item(s) at beginning
undefined
> arr.unshift(67); // Add 67 at begining of the array and return number of items in updated/new array
16
> arr
[ 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> arr.unshift(11, 22); // Adding 2 more items at the beginning of array
18
> arr
[ 11, 22, 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> // Define a method on array (temorarily) to remove an item and return the index of removed item; if it is found else return -1
undefined
> Array.prototype.remove = function(item) {
... var index = this.indexOf(item);
... if (index > -1) {
..... this.splice(index, 1); // splice() method is used to add/remove items in array
..... }
... return index;
... }
[Function]
>
> arr
[ 11, 22, 67, 45, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(45);   // Remove 45 (You will get the index of removed item)
3
> arr
[ 11, 22, 67, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(22)    // Remove 22
1
> arr
[ 11, 67, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
> arr.remove(67)    // Remove 67
1
> arr
[ 11, 67, 89, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(89)    // Remove 89
2
> arr
[ 11, 67, 34, 12, 7, 8, 3, -1, -4, -11, 0, 56, 12, 34 ]
>
> arr.remove(100);  // 100 doesn't exist, remove() will return -1
-1
>

Gracias.

1
hygull

Empalme, filtre y elimine para eliminar un elemento de la matriz

Cada matriz tiene su índice y ayuda a eliminar elementos particulares con su índice.

El método splice ()  

array.splice (index, 1 ); El primer parámetro es el índice y el segundo es el número de elementos que

desea eliminar de ese índice.

Así que para un solo elemento utilizamos 1. 

El método de eliminación

eliminar matriz [índice]

El método de filtro ()

Si desea eliminar un elemento que se repite en la matriz, filtre la matriz.

removeAll = array.filter (e => e! = elem);

donde elem es el elemento que desea eliminar de la matriz y la matriz es su nombre de matriz

1
ashish

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

array.splice (start [ deleteCount [ item1 [ item2 [ ...]]])

inicio

Índice en el que comenzar a cambiar la matriz (con Origen 0). Si es mayor que la longitud de la matriz, el índice de inicio real se establecerá en la longitud de la matriz. Si es negativo, comenzarán tantos elementos desde el final de la matriz (con Origen -1) y se establecerán en 0 si el valor absoluto es mayor que la longitud de la matriz.

deleteCount Opcional

Un número entero que indica el número de elementos de matriz antiguos para eliminar. Si se omite deleteCount, o si su valor es mayor que array.length - start (es decir, si es mayor que la cantidad de elementos que quedan en matriz, comenzando desde el inicio), entonces todos los elementos desde el inicio hasta el final de la matriz se eliminarán. Si deleteCount es 0 o negativo, no se eliminan elementos. En este caso, debe especificar al menos un elemento nuevo (ver más abajo).

item1, item2, ... Opcional

Los elementos para agregar a la matriz, comenzando en el índice de inicio. Si no especifica ningún elemento, splice () solo eliminará elementos de la matriz.

Para obtener más información, consulte amablemente:

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

0
ashish

Ya hay muchas respuestas, pero como nadie lo ha hecho con una sola línea, pensé que mostraría mi método. Aprovecha el hecho de que la función string.split () eliminará todos los caracteres especificados al crear una matriz. Aquí hay un ejemplo: 

var ary = [1,2,3,4,1234,10,4,5,7,3];
out = ary.join("-").split("-4-").join("-").split("-");
console.log(out);

En este ejemplo, todos los 4 se están eliminando de la matriz. Sin embargo, es importante tener en cuenta que cualquier matriz que contenga el carácter "-" causará problemas con este ejemplo. En resumen, hará que la función de unión ("-") junte la cadena de forma incorrecta. En tal situación, todas las cadenas "-" en el recorte anterior se pueden reemplazar con cualquier cadena que no se utilizará en la matriz original. Aquí hay otro ejemplo: 

var ary = [1,2,3,4,'-',1234,10,'-',4,5,7,3];
out = ary.join("[email protected]#").split("[email protected]#[email protected]#").join("[email protected]#").split("[email protected]#");
console.log(out);

0
Partial Science

Aprovechando el método de reducción de la siguiente manera:

caso a) si necesitas eliminar elemento por índice:

function remove(arr, index) {
  return arr.reduce((prev, x, i) => prev.concat(i !== index ? [x] : []), []);
}

caso b) si necesita eliminar el elemento por el valor del elemento (int):

function remove(arr, value) {
  return arr.reduce((prev, x, i) => prev.concat(x !== value ? [x] : []), []);
}

Así que de esta manera podemos devolver una nueva matriz (será una forma funcional excelente, mucho mejor que usar Empujar o empalmar) con el elemento eliminado.

0
alejoko
Array.prototype.remove = function(x) {
    var y=this.slice(x+1);
    var z=[];
    for(i=0;i<=x-1;i++) {
        z[z.length] = this[i];
    }

    for(i=0;i<y.length;i++){
        z[z.length]=y[i];
    }

    return z;
}
0
user4109793
var arr =[1,2,3,4,5];

arr.splice(0,1)

console.log(arr)

Salida [2, 3, 4, 5];

0
Shahriar Ahmad