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

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

const array = [2, 5, 9];

console.log(array);

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

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

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

En aras de la integridad, aquí hay funciones. La primera función elimina solo una aparición (es decir, elimina la primera coincidencia de 5 a partir de octubre XNUMX [2,5,9,1,5,8,5]), mientras que la segunda función elimina todas las apariciones:

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

function removeItemAll(arr, value) {
  var i = 0;
  while (i < arr.length) {
    if (arr[i] === value) {
      arr.splice(i, 1);
    } else {
      ++i;
    }
  }
  return arr;
}
// Usage
console.log(removeItemOnce([2,5,9,1,5,8,5], 5))
console.log(removeItemAll([2,5,9,1,5,8,5], 5))

En TypeScript, estas funciones pueden permanecer seguras para los tipos con un parámetro de tipo:

function removeItem<T>(arr: Array<T>, value: T): Array<T> { 
  const index = arr.indexOf(value);
  if (index > -1) {
    arr.splice(index, 1);
  }
  return arr;
}

Editado en octubre de 2016

• Hágalo simple, intuitivo y explícito (La navaja de Occam)
• Hazlo inmutable (la matriz original permanece sin cambios)
• Hágalo con funciones estándar de JavaScript, si su navegador no las admite: usar polyfill

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

Eliminación de elemento (código ECMA-262 Edición 5 también conocido como JavaScript de estilo antiguo)

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 ]

Eliminar elemento (código ECMAScript 6)

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 La sintaxis de la función de flecha ECMAScript 6 "() => {}" no es compatible con Internet Explorer, Chrome antes de la versión 45, Firefox antes de la versión 22 y Safari antes de la versión 10. Para usar la sintaxis de ECMAScript 6 en navegadores antiguos, puede usar BabelJS.

Eliminar varios elementos (código ECMAScript 7)

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 La función "array.includes (...)" no es compatible con Internet Explorer, 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.

Eliminar varios elementos (en el futuro, tal vez)

Si "Esta sintaxis vinculante" propuesta es aceptada, podrá hacer esto:

// array-lib.js

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

// main.js

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

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

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

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

Pruébelo usted mismo en BabelJS :)

Referencia

• Array.prototype.include
• Composición funcional

No se como estas esperando array.remove(int) a comportarse. Hay tres posibilidades en las que puedo pensar que es posible que desee.

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 hacer que el elemento esté en el índice i ya no existen, pero no desea que los índices de los otros elementos cambien:

delete array[i];

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

Si do quiero un espacio vacío:

array[index] = undefined;

Si no quiero un espacio vacío:

//To keep the original:
//oldArray = [...array];

//This modifies the array.
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];

Si desea eliminar en cualquier extremo de la matriz, puede usar array.pop() para el último o array.shift() para el primero (ambos devuelven el valor del artículo también).

Si no conoce el índice del artículo, puede usar array.indexOf(item) para conseguirlo (en un if() para obtener un artículo o en un while() para conseguirlos todos). array.indexOf(item) devuelve el índice o -1 si no se encuentra. 

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

Eliminar TODAS las instancias de una matriz

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

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

Hay dos enfoques principales:

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

2. borrar: delete anArray[index];

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

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

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

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

Array.prototype.remove_by_value = 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)
].remove_by_value(3);

Array.prototype.remove_by_value = 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.remove_by_value('hello')

console.log(rooms)

No hay necesidad de usar indexOf or 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 la herramienta indexOf y splice (índice de):

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

Usar unicamente splice (empalme):

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

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

índice de es aproximadamente 10 veces más lento que movimiento. Incluso si se mejora eliminando la llamada a indexOf in empalme funciona mucho peor que movimiento.

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

Puedes hacerlo fácilmente con el filtrar 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.

Juan 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 publico esto es para advertir a los usuarios contra la implementación alternativa sugerida en los comentarios de esa página (14 de diciembre de 2007):

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

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

myArray.remove(8);

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

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

salida:

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

Underscore.js se puede utilizar para resolver problemas con varios navegadores. Utiliza métodos de navegador integrados, si están presentes. Si están ausentes, como en el caso de las 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]

Si desea una nueva matriz con las posiciones eliminadas eliminadas, siempre puede eliminar el elemento específico y filtrar la matriz. Podría necesitar una extensión del objeto de matriz para navegadores que no implementan el método de filtro, pero a largo plazo es más fácil ya que todo lo que 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';}));

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

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

Todo el método descrito no mutes la matriz originaly, en su lugar, cree uno nuevo.

Si conoce el índice de un artículo

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

Un método es usar slice():

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

console.log(filteredItems)

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

Si conoces el valor

En este caso, una buena opción es utilizar filter(), que ofrece una mayor declarativo enfoque:

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

console.log(filteredItems)

Utiliza las funciones de flecha de ES6. Puede utilizar 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 transpilar el código ES6 de nuevo 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?

Busquemos la solución más simple.

Por índice

Puede simplemente crear una función y eliminar elementos en serie:

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

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

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

console.log(filteredItems)

Por valor

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

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

console.log(filteredItems)

Evite mutar la matriz original

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

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

Mira este código. Funciona en todos navegador principal.

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

var array = [1,3,5,6,5,9,5,3,55]
var res = remove_item(array,5);
console.log(res)

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

const removeByIndex = (list, index) =>
      [
        ...list.slice(0, index),
        ...list.slice(index + 1)
      ];
         
output = removeByIndex([33,22,11,44],1) //=> [33,11,44]
      
console.log(output)

Puedes usar lodash _.jalar (matriz mutada), _.tirar (matriz mutada) o _.sin (no muta la matriz),

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

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

var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without(array3, 'i') // ['j', 'k', 'l']
console.log(array3) // ['i', 'j', 'k', 'l']

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

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

dónde:

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

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

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

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

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

Dependiendo de si tiene una versión más nueva o más antigua de Ecmascript ejecutándose en las computadoras de su cliente:

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

OR

var array = ['1','2','3','4','5','6'];
var newArray = array.filter(function(item){ return item !== '3' });

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

Rendimiento

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

Las conclusiones

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

Detalles

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

Resultados de una matriz con 10 elementos

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

Resultados de una matriz con 1.000.000 elementos

En Chrome el array.splice (C) es la solución in situ más rápida (la delete (C) es similar rápido, pero dejó una ranura vacía en la matriz (por lo que no realiza una 'eliminación completa')). La array.slice-splice (H) es la solución inmutable más rápida. El mas lento es array.filter (D y E). Puede realizar la prueba en su máquina aquí.

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

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

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

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

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

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

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

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

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

A([...a]);
B([...a]);
C([...a]);
D([...a]);
E([...a]);
F([...a]);
G([...a]);
H([...a]);

This snippet only presents code used in performance tests - it does not perform tests itself.

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

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

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

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

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

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

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

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

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

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

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

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

Luego, cuando quiera 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. ["elemento1", "elemento1"]

Es posible que tenga necesidades diferentes a las mías, por lo que puede modificarlo fácilmente para adaptarlo a ellas. Espero que esto ayude a alguien.

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

Por ejemplo, si tiene un objeto con un campo Id y desea que el objeto se elimine de una matriz:

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

Quiero responder basándome en ECMAScript 6. Suponga que tiene una matriz como la siguiente:

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

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

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

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

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

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

Actualizar: Este método se recomienda solo si no puede usar ECMAScript 2015 (anteriormente conocido como ES6). Si puede usarlo, otras respuestas aquí brindan implementaciones mucho más ordenadas.

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

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

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

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

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

    return destroyed;
}

Uso:

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

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

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

x.destroy(3);         // => null
x;                    // => [1, 2]

Actualización de ES10

Esta publicación resume los enfoques comunes para la eliminación de elementos de una matriz a partir de ECMAScript 2019 (ES10).

1. Casos generales

1.1. Eliminando el elemento Array por valor usando .splice()

| En su lugar: Si |
| Elimina duplicados: Sí (bucle), No (indexOf) |
| Por valor / índice: Por índice |

Si conoce el valor que desea eliminar de una matriz, puede usar el método de empalme. Primero, debe identificar el índice del elemento de destino. Luego, usa el índice como elemento de inicio y elimina solo un elemento.

// With a 'for' loop
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
for( let i = 0; i < arr.length; i++){
  if ( arr[i] === 5) {
    arr.splice(i, 1);
  }
} // => [1, 2, 3, 4, 6, 7, 8, 9, 0]

// With the .indexOf() method
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf(5);
arr.splice(i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]

1.2. Eliminando el elemento Array usando el .filter() Método

| En su lugar: No |
| Elimina duplicados: Si |
| Por valor / índice: Por valor |

El elemento específico puede ser filtrado de la matriz, proporcionando una función de filtrado. A continuación, se llama a dicha función para cada elemento de la matriz.

const value = 3
let arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter(item => item !== value)
console.log(arr)
// [ 1, 2, 4, 5 ]

1.3. Eliminando el elemento Array extendiendo Array.prototype

| En su lugar: Sí / No (depende de la implementación) |
| Elimina duplicados: Sí / No (depende de la implementación) |
| Por valor / índice: Por índice / Por valor (Depende de la implementación) |

El prototipo de Array se puede ampliar con métodos adicionales. Estos métodos estarán disponibles para su uso en matrices creadas.

Nota: Algunos consideran que extender prototipos de objetos de la biblioteca estándar de JavaScript (como Array) es un antipatrón.

// In-place, removes all, by value implementation
Array.prototype.remove = function(item) {
    for (let i = 0; i < this.length; i++) {
        if (this[i] === item) {
            this.splice(i, 1);
        }
    }
}
const arr1 = [1,2,3,1];
arr1.remove(1) // arr1 equals [2,3]

// Non-stationary, removes first, by value implementation
Array.prototype.remove = function(item) {
    const arr = this.slice();
    for (let i = 0; i < this.length; i++) {
        if (arr[i] === item) {
            arr.splice(i, 1);
            return arr;
        }
    }
    return arr;
}
let arr2 = [1,2,3,1];
arr2 = arr2.remove(1) // arr2 equals [2,3,1]

1.4. Eliminando el elemento Array usando el delete operador

| En su lugar: Si |
| Elimina duplicados: No |
| Por valor / índice: Por índice |

El uso del operador de eliminación no afecta la propiedad de longitud. Tampoco afecta los índices de elementos posteriores. La matriz se vuelve escasa, lo que es una forma elegante de decir que el elemento eliminado no se elimina sino que se vuelve indefinido.

const arr = [1, 2, 3, 4, 5, 6];
delete arr[4]; // Delete element with index 4
console.log( arr ); // [1, 2, 3, 4, undefined, 6]

El operador de eliminación está diseñado para eliminar propiedades de los objetos de JavaScript, cuyas matrices son objetos.

1.5. Eliminando el elemento Array usando Object utilidades (> = ES10)

| En su lugar: No |
| Elimina duplicados: Si |
| Por valor / índice: Por valor |

ES10 introducido Object.fromEntries, que se puede utilizar para crear la matriz deseada a partir de cualquier objeto similar a una matriz y filtrar elementos no deseados durante el proceso.

const object = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values(Object.fromEntries(
  Object.entries(object)
  .filter(([ key, val ]) => val !== valueToRemove)
));
console.log(arr); // [1,2,4]

2. Casos especiales

2.1 Eliminar elemento si está al final de la matriz

| En su lugar: Si |
| Elimina duplicados: No |
| Por valor / índice: N / A |

Los elementos de JavaScript Array se pueden eliminar del final de una matriz estableciendo la propiedad length en un valor menor que el valor actual. Se eliminará cualquier elemento cuyo índice sea mayor o igual que la nueva longitud.

const arr = [1, 2, 3, 4, 5, 6];
arr.length = 5; // Set length to remove element
console.log( arr ); // [1, 2, 3, 4, 5]

| En su lugar: Si |
| Elimina duplicados: No |
| Por valor / índice: N / A |

El método pop elimina el último elemento de la matriz, devuelve ese elemento y actualiza la propiedad de longitud. El método pop modifica la matriz en la que se invoca. Esto significa que, a diferencia de eliminar, el último elemento se elimina por completo y la longitud de la matriz se reduce.

const arr = [1, 2, 3, 4, 5, 6];
arr.pop(); // returns 6
console.log( arr ); // [1, 2, 3, 4, 5]

2.2. Eliminando elemento si está al comienzo de la matriz

| En su lugar: Si |
| Elimina duplicados: No |
| Por valor / índice: N / A |

EL .shift() El método funciona de manera muy similar al método pop, excepto que elimina el primer elemento de una matriz de JavaScript en lugar del último. Cuando se quita el elemento, los elementos restantes se desplazan hacia abajo.

const arr = [1, 2, 3, 4];
arr.shift(); // returns 1
console.log( arr ); // [2, 3, 4]

2.3. Eliminar elemento si es el único elemento en la matriz

| En su lugar: Si |
| Elimina duplicados: N / A |
| Por valor / índice: N / A |

La técnica más rápida es establecer una variable de matriz en una matriz vacía.

let arr = [1];
arr = []; //empty array

Alternativamente, se puede utilizar la técnica de 2.1.1 estableciendo la longitud en 0.

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

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

Suponga que quiere eliminar 5 de la matriz, simplemente puede hacerlo así:

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

Esto le dará una nueva matriz sin el valor que 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 Filtro de matriz.

Puede hacer un bucle hacia atrás para asegurarse de no estropear 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);
}
console.log(myArray);

Demo en vivo

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

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

Entonces:

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

Flexible:

[1, 2, 4]

Puedes usar Babel y servicio polyfill para garantizar que sea compatible con todos los navegadores.

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

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

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

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

Si desea varios valores. Ejemplo: - 1,7,8

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

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

console.log("new Array, 1,7 and 8 removed", newNumberArray);

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

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

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

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

Incluye navegador compatible es aquí.