¿Cómo puedo eliminar un determinado elemento de un array en JavaScript?

Encontrar el index de la matriz de elemento que desea eliminar el uso de indexOf y, a continuación, quitar ese índice con empalme.

El método splice() cambia el contenido de una matriz mediante la eliminación de
de los elementos existentes y/o la adición de nuevos elementos.

JS:

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.

No sé de qué estás esperando array.remove(int) comportarse. Hay tres posibilidades que puedo pensar que usted podría querer.

Para eliminar un elemento de un array 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 lo que desea es hacer el elemento en el índice i ya no existen, pero no desea que los índices de los otros elementos para el cambio:

delete array[i];

Editado en el año 2016 octubre

• Hacer es simple, intuitiva y explícito (La navaja de Occam)
• Hacer es inmutable (matriz original permanecer sin cambios)
• Hacerlo con el estándar de funciones de JavaScript, si su navegador no los apoyan – uso polyfil

En este ejemplo de código que uso «de la matriz.filtro(…)» función para eliminar elementos no deseados de la matriz. Esta función no cambia la matriz original y crea una nueva. Si su navegador no soporta esta función (por ejemplo, Internet Explorer anteriores a la versión 9, o Firefox antes de la versión 1.5), considere el uso de el filtro relleno de Mozilla.

La eliminación de elemento (ECMA-262 Edición 5 código aka oldstyle JavaScript)

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 ]

La eliminación de elemento (ECMAScript 6 código)

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 ECMAScript 6 «() => {}» flecha sintaxis de la función no se admite en Internet Explorer a todos, Chrome antes de los 45 versión, Firefox antes del 22 de versión, y Safari antes de las 10 de la versión. El uso de ECMAScript 6 sintaxis en navegadores antiguos, puede utilizar BabelJS.

---

La eliminación de elementos múltiples (ECMAScript 7 código)

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 ]

IMPORTANTE «de la matriz.incluye(…)» la función no se admite en Internet Explorer a todos, Chrome antes de 47 versión, Firefox antes de 43 versión, Safari antes de las 9 de la versión, y el Borde antes de las 14 versión para aquí está relleno de Mozilla.

La eliminación de varios elementos (en el futuro, tal vez)

Si el «Esta Unión De La Sintaxis» propuesta es cada vez aceptado, usted será capaz de 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 ]

Pruebe usted mismo en BabelJS 🙂

Referencia

• De la matriz.el prototipo.incluye
• Composición funcional

Depende de si usted desea mantener un punto vacío o no.

Si quieres una ranura vacía, eliminar esta bien:

delete array[index];

Si no, usted debe utilizar el empalme método:

array.splice(index, 1);

Y si se necesita el valor de ese elemento, sólo se puede almacenar el array devuelto del elemento:

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

En caso de querer hacerlo en un poco de orden, puede utilizar array.pop() para los últimos uno o array.shift() para el primero (y devuelven el valor del elemento demasiado).

Y si no sabes el índice del elemento, puede utilizar array.indexOf(item) conseguirlo (en un if() para obtener un artículo o en un while() para llegar a todos ellos). array.indexOf(item) devuelve el índice o -1 si no se encontró. 

Un amigo estaba teniendo problemas en Internet Explorer 8 y me mostró lo que él hizo. Yo le dije que estaba mal, y él me dijo que él tiene la respuesta aquí. Esta vez la respuesta no va a funcionar en todos los navegadores (Internet Explorer 8 por ejemplo), y que sólo va a quitar la primera ocurrencia 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 (desde índices de longitud y va a cambiar a medida que se eliminan los elementos) y se elimina el elemento, si se encuentra. Funciona en todos los navegadores.

Hay dos enfoques principales:

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

2. eliminar: delete anArray[index];

Tener cuidado cuando se utiliza para eliminar una matriz. Es bueno para eliminar los atributos de los objetos, pero no tan bueno para las matrices. Es mejor utilizar splice para las matrices.

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

También se puede esperar a tener agujeros en los números de índice después de eliminar el uso de, por ejemplo, usted podría terminar encima de tener los índices de 1, 3, 4, 8, 9, y 11 y la longitud como estaba antes de utilizar eliminar. En ese caso, todos los indexados for bucles de accidente, ya que los índices no son secuenciales.

Si se ve forzado a usar delete por alguna razón, entonces usted debe utilizar para cada bucles cuando usted necesita un bucle a través de matrices. Como cuestión de hecho, siempre evite el uso de indexado for bucles, si es posible. De esa manera, el código sería el más robusto y menos propensos a tener problemas con los índices.

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

JS:

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)

No hay necesidad de utilizar indexOf o splice. Sin embargo, funciona mejor si usted sólo desea quitar una ocurrencia de un elemento.

Encontrar y mover (move):

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

Uso indexOf y splice (porcentaje):

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

Utilizar sólo splice (empalme):

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

Los tiempos de ejecución en nodejs para la matriz con 1000 elementos (un promedio de más de 10000 carreras):

indexof es aproximadamente 10 veces más lento que mover. Incluso si mejoró mediante la eliminación de 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

Esto proporciona un predicado en lugar de un valor.

NOTA: es la actualización de la matriz dada, y el retorno a 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;
    }
};

John Resig publicado una buena aplicació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 usted no desea extender un objeto global, usted puede hacer algo como lo siguiente, en lugar de:

//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 principal razón por la que estoy publicando esto es para advertir a los usuarios frente a la alternativa de implementación sugerido en los comentarios en la página (Dec 14, 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 que he descubierto se produce un error al intentar eliminar el último elemento de una matriz. Por ejemplo, si usted tiene un 10-elemento de la matriz y de intentar quitar el 9 de elemento con esto:

myArray.remove(8);

Usted termina con una de 8 elementos de la matriz. No sé por qué, pero me confirmó Juan de la implementación original no tiene este problema.

Underscore.js puede ser usado para resolver problemas con varios navegadores. Se utiliza en construir métodos de explorador si está presente. Si están ausentes, como en el caso de mayores de Internet Explorer versiones usa sus propios métodos.

Un ejemplo sencillo para eliminar elementos de la matriz (de la web):

_.without([1, 2, 1, 0, 3, 1, 4], 0, 1); //=> [2, 3, 4]

Usted puede hacerlo fácilmente con la filtro 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.

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

De salida :

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

Si quieres un nuevo array con el borrado de las posiciones eliminado, siempre se puede eliminar el elemento específico y filtro de salida de la matriz. Es posible que tenga una extensión de la objeto array para los navegadores que no implementan el método de filtro, pero en el largo plazo es más fácil ya que todo lo que hago 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].

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

Puede utilizar lodash _.tire (mutar matriz), _.pullAt (mutar matriz) o _.sin (no mutar 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']

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

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

Y queremos eliminar el número 4. Usted puede simplemente utilizar el siguiente código:

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

Si usted está utilizando esta función, se escribe una función reutilizable que se adjunta a la nativo función de matriz como la siguiente:

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 ¿y si tiene la siguiente matriz en su lugar con un par de [5]s en la matriz?

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

Necesitamos un bucle para comprobar todos ellos, pero es más fácil y más eficiente es el uso integrado de las funciones de JavaScript, por lo que podemos escribir una función que utiliza un filtro como el de abajo, lugar:

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 ayudan a hacer esto, como Lodash o Subrayado. Para obtener más información, busque en lodash _.tire, _.pullAt o _.sin.

Aquí están algunas maneras de quitar un elemento de una matriz mediante JavaScript.

Todo el método descrito no mutan a la matriz original, y en lugar de crear uno nuevo.

Si usted sabe que el índice de un elemento

Supongamos que tenemos una matriz, y desea eliminar un elemento en la posición i.

Un método es utilizar slice():

JS:

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 un nuevo array con los índices que recibe. Simplemente debemos crear una nueva matriz, desde el inicio hasta el índice que desea eliminar, y concatenar otra matriz de la posición siguiente al de la que hemos eliminado al final de la matriz.

Si sabe el valor

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

JS:

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

console.log(filteredItems)

Para ello se utiliza el ES6 flecha funciones. Puede utilizar las funciones tradicionales para soportar los navegadores más antiguos:

JS:

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 utilizar Babel y transpile la ES6 código del ES5 para hacerla más digerible para los navegadores antiguos, sin embargo, la escritura moderna de JavaScript en el código.

La eliminación de varios elementos

¿Y si en vez de un único elemento que desea eliminar muchos de los artículos?

Vamos a encontrar la solución más simple.

Por índice

Usted puede crear una función y eliminar elementos en serie:

JS:

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

Usted puede buscar para su inclusión dentro de la función de devolución de llamada:

JS:

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)

Evitar la mutación de la matriz original

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

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

Soy bastante nuevo en JavaScript y necesita esta funcionalidad. Simplemente me escribió 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");

De salida – Como se esperaba.
[«elemento1», «elemento1»]

Usted puede tener diferentes necesidades que yo, así que usted puede modificar fácilmente para adaptarse a ellos. Espero que esto ayude a alguien.

ES6 & sin mutación: (octubre de 2016)

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

A continuación :

removeByIndex([33,22,11,44],1) //=> [33,11,44]

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

E. g. si tienes un objeto con un campo de Id y desea que el objeto se elimina de una matriz:

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

Actualización: se recomienda Este método sólo si no puede utilizar ECMAScript 2015 (anteriormente conocido como ES6). Si se puede usar, otras respuestas aquí es mucho más prolijo de las implementaciones.

---

Esta esencia aquí va a resolver su problema, y también elimina todas las ocurrencias de la discusión en lugar de sólo 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]

Quiero respuesta basada en la ECMAScript 6. Asumir, tiene una matriz como la siguiente:

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

Si desea eliminar en un índice especial como 2, escribir 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 de su índice, hacer como la siguiente:

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

Sugerencia: por favor, utilice una flecha función de filtro de devolución de llamada, a menos que usted conseguirá un array vacío.

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

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

Suponga que desea eliminar 5 de la matriz, puede simplemente hacer como este:

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

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

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

Para un mayor entendimiento se puede leer el MDN documentación en De la matriz.filtro.

Una más moderna, ECMAScript 2015 (anteriormente conocida como la Armonía o ES 6) enfoque. Dado:

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

A continuación:

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

Rendimiento:

[1, 2, 4]

Puede utilizar Babel y un relleno de servicio para asegurar que este está bien soportado en todos los navegadores.

La eliminación de un elemento en particular/string a partir de una matriz se puede hacer en una sola línea:
Todavía creo que este es el más elegante una línea que usted puede conseguir para este tipo de problema:

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

donde
theArray es la matriz que desea quitar algo particular, stringToRemoveFromArray es la cadena que desea eliminar y 1 es la cantidad de elementos que desea quitar.

Que tienen de 1 a 9 en la matriz, y desea quitar 5. Usar el siguiente código:

JS:

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

JS:

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 quieres eliminar un valor de matriz en una matriz. Ejemplo: [3,4,5]

JS:

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, es enlace.

Sé que hay un montón de respuestas ya, pero muchos de ellos se parecen más a complicar el problema. Aquí es un simple, recursiva manera de eliminar todas las instancias de una clave – llama a sí mismo hasta el índice no se encuentra. Sí, sólo funciona en los navegadores con indexOf, pero es muy simple y puede ser fácilmente polyfilled.

Independiente de la función

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

    if(index === -1) return;

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

Prototipo método

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

    if(index === -1) return;

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

Basado en todas las respuestas que eran principalmente correcta y teniendo en cuenta las mejores prácticas sugeridas (especialmente el uso de la Matriz.prototipo directamente), me encontré con 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;
}

La revisión de la función anterior, a pesar del hecho de que funciona bien, me di cuenta de que podría haber algo de mejora en el rendimiento. También el uso de ES6 en lugar de ES5 es un enfoque mucho mejor. Con 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 un blog en el que he comparado varias soluciones para la Matriz sin problema y en comparación con el tiempo que se tarda en ejecutar. Voy a actualizar esta respuesta con el enlace una vez que termine ese post. Sólo para hacerle saber, he comparado los de arriba contra lodash del sin y en caso de que el navegador soporta Map, es mejor que lodash! Aviso que no estoy utilizando Array.prototype.indexOf o Array.prototype.includes como envolver el exlcudeValues en un Map o Object hace consultar más rápido!

Usted puede hacer un bucle hacia atrás para asegurarse de no meter la pata hasta 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);
}

Demostración En Vivo

Tengo otra buena solución para la eliminación 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

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

Quitar por el Índice de

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

Quitar por Valor

Función que devuelve una copia de la matriz sin 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]

Crear nueva matriz:

var my_array = new Array();

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

De verificación índice de este elemento (probado con Firefox y Internet Explorer 8 (y último):

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

Quitar 1 elemento situado en el índice de la matriz

my_array.splice(index, 1);

También participé en la situación en la que tuve que quitar un elemento de Array. .indexOf no estaba trabajando en IE* para compartir mi trabajo jQuery.inArray() solución.

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

Creo que muchas de las instrucciones JavaScript no está bien pensado para la programación funcional. Empalme devuelve el borrado del elemento donde la mayoría del tiempo que necesita la reducción de la matriz. Esto es malo.

Imagínese que usted está haciendo una llamada recursiva, y tienen que pasar una matriz con un menor elemento, probablemente sin la actual indexada artículo. O imagínese que usted está haciendo otra llamada recursiva, y tiene que pasar un array con un elemento empujado.

En ninguno de estos casos se puede realizar myRecursiveFunction(myArr.push(c)) o myRecursiveFunction(myArr.splice(i,1)). El primer idiota en el hecho de pasar la longitud de la matriz y el segundo idiota va a pasar el borrado del elemento como un parámetro.

Así que lo que hago en realidad… Para eliminar un elemento de la matriz y de paso de la resultante a una función como un parámetro en el mismo tiempo hago de la siguiente manera

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

Cuando se trata de empuje que es más tonto… me gusta,

myRecursiveFunction((myArr.push(c),myArr))

Creo en un adecuado lenguaje funcional de un método de mutación del objeto es llamado debe devolver una referencia al objeto mismo como un resultado.

2017-05-08

La mayoría de las respuestas posibles de trabajo para la comparación estricta, lo que significa que tanto los objetos de referencia exactamente el mismo objeto en memoria (o son tipos primitivos), pero a menudo se desea eliminar un no-objeto primitivo de una matriz que tiene un cierto valor. Por ejemplo, si usted hace una llamada a un servidor y desea comprobar un objeto recuperado en contra de 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 alternativa/implementaciones más rápidas para valuesAreEqual, pero esto no hace el trabajo. También puede usar un comparador de si usted tiene un campo específico de verificación (por ejemplo, algunos recuperados UUID frente a un local UUID).

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

[2,3,5].filter(i => ![5].includes(i))

Muchas veces es mejor crear un nuevo array con los filter función.

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

Esto también mejora la legibilidad en mi humilde opinión. Yo no soy un fan de slice, aunque sé que a veces hay que ir por ella.

En CoffeeScript:

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

Uso de 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 no se encontró el elemento.

Se puede iterar sobre cada array-objeto y splice si existen 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;
}

Me gusta esta versión de empalme, la eliminación de un elemento por su valor de uso $.inArray:

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

Retire el elemento en el índice i, sin la mutación de 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);
}

JavaScript (ES5.1) – en lugar edición

Soporte de los navegadores: Internet Explorer 9 o posterior (detallada de la compatibilidad 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 (ES5.1) – inmutable edición

Soporte de los navegadores: lo Mismo que JavaScript en lugar de la edición

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

Vainilla ES6 – inmutable edición

Soporte de los navegadores: Chrome 46, Edge 12, Firefox 16, Opera 37, Safari 8 (detallada de la compatibilidad 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;
}

Por mi solución puede eliminar uno o más de un elemento en 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]

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

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

Acabo de crear un polyfill en el Array.prototype a través de Object.defineProperty para eliminar un elemento deseado en una matriz sin dar lugar a errores cuando se itera sobre ella más tarde a través for .. in ..

La eliminación de un valor entero

Extracción de una cadena de valor

La eliminación de un valor booleano

También es posible eliminar un objeto en el interior de la matriz a través de este Array.prototype.remove método. Sólo necesitas especificar el key => value de la Object desea quitar.

La eliminación de un objeto de valor

Uso jQuery.grep():

JS:

HTML:

Mientras que la mayoría de las respuestas anteriores responder a la pregunta, no es lo suficientemente claro por qué el slice() método no ha sido utilizado. Sí, filter() cumple con la inmutabilidad de los criterios, pero, ¿cómo hacer el siguiente corto equivalente?

Y ahora vamos a decir que debemos eliminar el segundo elemento de la matriz, se puede hacer simplemente:

Esta forma de eliminar un elemento de una matriz se anima hoy en día en la comunidad debido a su simple e inmutable de la naturaleza. En general, los métodos que causa la mutación debe ser evitado. Por ejemplo, se recomienda reemplazar push() con concat() y splice() con slice().

Hice una función:

Y utilizado como este:

Eliminar un valor, mediante sueltas de comparación, sin la mutación de la matriz original, ES6

Eliminar un elemento de última

Eliminar un elemento de primer

Eliminar del medio

Eliminar un elemento de la última

Eliminar mediante el uso de un número de índice de matriz

Eliminando el valor con el índice y el empalme!

Quitar la última ocurrencia de una o todas las veces, o la primera aparición?

o

Post de mi código que elimina un elemento de la matriz en su lugar, y reducir la longitud de matriz así.

Para todos los que buscan replicar un método que devuelve una nueva matriz que se ha duplicado números o cadenas de caracteres se retiran, este ha sido elaborado a partir de las respuestas:

El Uso De La Matriz.findindex, podemos reducir el número de líneas de código.

developer.mozilla.org

Su pregunta no indican si la orden o valores distintos son un requisito.

Si usted no se preocupan por fin, y no tendrá el mismo valor en el contenedor más de una vez, el uso de un Conjunto. Será más rápido y más breve.

Hay muchas fantásticas respuestas aquí, pero para mí, lo que funcionó la mayoría simplemente no estaba quitando el elemento de la matriz por completo, sino simplemente establecer el valor de a null.

Esto funciona para la mayoría de los casos que tengo y es una buena solución, ya que voy a estar usando la variable más tarde y no quieres que se ha ido, sólo vacío por ahora. Además, este enfoque es completamente compatible con distintos navegadores.

Una muy ingenuo aplicación sería el siguiente:

JS:

Puedo devolver la longitud de la matriz de la función a cumplir con los otros métodos, como la Array.prototype.push().

Esta solución tendrá una matriz de entrada y búsqueda a través de la entrada para el valor de quitar. Este bucle a través de toda la matriz de entrada y el resultado será una segunda matriz de enteros que ha tenido el índice específico eliminado. Los enteros de la matriz a continuación, se copia de nuevo en la matriz de entrada.

El siguiente método será eliminar todas las entradas de un determinado valor de una matriz sin necesidad de crear una nueva matriz y con sólo una iteración que se superfast. Y funciona en la antigua Internet Explorer 5.5 navegador:

JS:

HTML:

Lo que es una vergüenza tiene una matriz de enteros, no un objeto, donde las claves son cadenas equivalentes de estos enteros.

He mirado a través de una gran cantidad de estas respuestas, y todos ellos parecen uso de la «fuerza bruta», por lo que puedo ver. No he examinado cada uno de ellos, le pido disculpas si esto no es así. Para una pequeña matriz de esto está muy bien, pero lo que si tiene 000s de enteros en ella?

Me corrija si estoy equivocado, pero no podemos asumir que en un key => value mapa, del tipo de los que un objeto JS es, que la clave del mecanismo de recuperación puede ser asumida como altamente diseñado y optimizado? (NOTA: si algunos super-experto me dice que este no es el caso, me puede sugerir el uso de ES6 del Mapa de la clase lugar, que sin duda va a ser).

Sólo estoy sugiriendo que, en ciertas circunstancias, la mejor solución podría ser la de convertir la matriz a un objeto… el problema es, por supuesto, que usted podría tener la repetición de valores enteros. Sugiero poner aquellos en los cubos como el «valor» de la parte de la key => value entradas. (NOTA: si está seguro de que usted no tiene repetición de elementos de la matriz de esto puede ser mucho más simple: los valores de «igual» de las teclas, y sólo tiene que ir Object.values(...) de volver a su matriz modificada).

Así que usted podría hacer:

de salida:

Objeto [ <1 ranura vacía>, Matriz deUno, Matriz[2], la Matriz deUno, Matriz deUno, <5
las ranuras vacías>, de 46 años y más… ]

esta forma, es fácil de eliminar todos los números de 55

Usted no tiene que eliminar a todos ellos: los valores del índice son empujados en sus cubos en orden de aparición, así que (por ejemplo):

borrará la primera y última aparición, respectivamente. Usted puede contar la frecuencia de ocurrencia fácilmente, vuelva a colocar todos de 55 años con 3s por transferir el contenido de un cubo a otro, etc.

… volver a sus modificado int matriz es ligeramente involucrados: pero cada cubo contiene el índice (en la matriz original) del valor representado por el (string key). Cada uno de estos cubo de valores es también único: de modo que se convierten en las claves de un nuevo objeto, con el (verdadero) entero de la «integer clave de la cadena» como valor… luego ordenar las llaves e ir Object.values( ... ).

Esto suena muy involucrados y consume mucho tiempo… pero obviamente todo depende de las circunstancias y de uso deseada. Mi entendimiento es que todas las versiones y contextos de la JS, solo funcionan en un hilo, y el hilo no «dejar ir», por lo que podría ser un horrible congestión con una «fuerza bruta» método: causadas no tanto por la indexOf ops, pero repetidos múltiples slice/splice ops.

Anexo

Si estás seguro esto es demasiado ingeniería para el caso de uso, seguramente la más simple «fuerza bruta» es

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

Tuve este problema (en una situación en la que la sustitución de la matriz fue aceptable) y la resolvió con un simple:

Para dar el fragmento anterior un poco de contexto:

Esta solución debe trabajar con la información de referencia y el valor de los artículos. Todo depende de si usted necesita para mantener una referencia a la matriz original en cuanto a si esta solución es aplicable.

Para mí la más simple es la mejor, y como estamos en el 2018 (cerca de 2019), te doy este (cerca de) la línea para responder a la pregunta original:

La cosa útil es que se puede utilizar en un curry de expresión, tales como:

Para eliminar un determinado elemento o los elementos posteriores, De la matriz.splice() método funciona bien.

El método splice() cambia el contenido de una matriz mediante la eliminación o sustitución de los elementos existentes y/o la adición de nuevos elementos, y devuelve el elemento eliminado(s).

Sintaxis: matriz.splice(índice, deleteCount, artículo 1, ….., itemX)

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

Por ejemplo:

Nota: De la matriz.splice() método puede ser usado si se conoce el índice del elemento que desea eliminar. Pero podemos tener un poco más de los casos que se mencionan a continuación:

1. En caso de que desea eliminar sólo el último elemento, puede utilizar De la matriz.pop()

2. En caso de que desea eliminar sólo el primer elemento, puede utilizar De la matriz.shift()

3. Si sabe el elemento por sí solo, pero no la posición (o índice) del elemento, y desea eliminar todos los elementos coincidentes mediante De la matriz.filter() método:

   O mediante el método splice() como:

   O supongamos que queremos eliminar del de la matriz arr:

   O

4. Si sabe el elemento por sí solo, pero no la posición (índice) del elemento, y desea eliminar sólo en muy primer elemento coincidente utilizando el método splice ():

De empalme, filtrar y eliminar para eliminar un elemento de una matriz

Cada matriz tiene su índice, y ayuda a eliminar un elemento en particular con su índice.

El método splice ()

matriz.splice(índice, 1);

El primer parámetro es el índice y el segundo es el número de elementos que desea eliminar de ese índice.

Modo para un solo elemento, se uso 1.

El método delete

eliminar de la matriz[índice]

El método filter ()

Si desea eliminar un elemento que se repite en una matriz, a continuación, el filtro de la matriz:

Donde elem es el elemento que desea eliminar de la matriz y array es el nombre de la matriz.

Si usted debe apoyar a las versiones anteriores de Internet Explorer, recomiendo usar la siguiente relleno (nota: este es no un marco). Es 100% compatible con la sustitución de todos los modernos de la matriz de métodos (JavaScript 1.8.5 /ECMAScript 5 Matriz de Extras) que funciona para Internet Explorer 6+, Firefox 1.5+, Chrome, Safari, & Ópera.

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

Definir un método llamado remove() en un array de objetos mediante la generación de prototipos de función de JavaScript.

Uso splice() método para cumplir su requisito.

Por favor, eche un vistazo a el siguiente código.

Nota: El siguiente es el ejemplo completo código que se ejecuta en el 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 beginning 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 (temporarily) 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
>

La mayoría de las respuestas que aquí se dan una solución con –

1. indexOf y empalme
2. eliminar
3. filtro
4. regular for loop

A pesar de todas las soluciones que se debe trabajar con estos métodos, pensé que podía el uso de la manipulación de cadenas.

Puntos a tener en cuenta acerca de esta solución –

1. Va a salir de los agujeros en los datos. (podría ser quitado con filtro adicional)
2. Esta solución obras no sólo primitiva de búsqueda de valores, pero también objetos.

El truco es –

1. stringify conjunto de datos de entrada y el valor de búsqueda
2. reemplazar el valor de búsqueda en el conjunto de datos de entrada con la cadena vacía
3. volver split datos sobre delimitador ,.

    remove = (input, value) => {
const stringVal = JSON.stringify(value);
const result = JSON.stringify(input)
return result.replace(stringVal, "").split(",");
}

Un JS de violín con las pruebas para los objetos y los números se crea aquí – https://jsfiddle.net/4t7zhkce/33/

Comprobar la remove método en el violín.

Para encontrar y eliminar una cadena particular de una matriz de cadenas:

var colors = ["red","blue","car","green"];
var carIndex = colors.indexOf("car");//get  "car" index
//remove car from the colors array
colors.splice(carIndex, 1); //colors = ["red","blue","green"]

Fuente: https://www.codegrepper.com/?search_term=remove+un+particular+elemento+de+la matriz de

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

Ya hay un montón de respuestas, pero porque nadie lo ha hecho con un forro sin embargo, pensé que había que mostrar mi método. Se aprovecha el hecho de que la cadena.split() de la función de eliminar todos los caracteres especificados al crear una matriz. Aquí está un ejemplo:

JS:

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 de la 4 están siendo retirados de la matriz de ary. Sin embargo, es importante tener en cuenta que cualquier matriz que contiene el carácter «-» va a causar problemas con este ejemplo. En definitiva, hará que el join(«-«) de la función a la pieza de su cadena junto incorrectamente. En tal situación, todos los «-» de las cadenas en el anterior snipet se puede reemplazar con cualquier cadena que no serán utilizados en la matriz original. Aquí está otro ejemplo:

JS:

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

var arr =[1,2,3,4,5];
arr.splice(0,1)
console.log(arr)

De salida [2, 3, 4, 5];

No en lugar de la solución de

arr.slice(0,i).concat(arr.slice(i+1));

JS:

let arr = [10, 20, 30, 40, 50]
let i = 2 ; //position to remove (starting from 0)
let r = arr.slice(0,i).concat(arr.slice(i+1));
console.log(r);

Quitar único elemento

function removeSingle(array, element) {
const index = array.indexOf(element)
if (index >= 0) {
array.splice(index, 1)
}
}

Eliminar varios elementos, en lugar

Esto es más complicado para garantizar que el algoritmo se ejecuta en O(N) tiempo.

function removeAll(array, element) {
let newLength = 0
for (const elem of array) {
if (elem !== number) {
array[newLength++] = elem
}
}
array.length = newLength
}

Eliminar varios elementos, la creación de nuevos objetos

array.filter(elem => elem !== number)