Eu tenho uma matriz de números e estou usando o .push()método para adicionar elementos a ele.

Existe uma maneira simples de remover um elemento específico de uma matriz?

Estou procurando o equivalente a algo como:

array.remove(number);

Eu tenho que usar o JavaScript principal . Estruturas não são permitidas.

Encontre o indexelemento da matriz que você deseja remover usando indexOfe remova esse índice com splice.

O método splice () altera o conteúdo de uma matriz removendo os elementos existentes e / ou adicionando novos elementos.

const array = [2, 5, 9];

console.log(array);

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

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

O segundo parâmetro de spliceé o número de elementos a serem removidos. Observe que splicemodifica a matriz no local e retorna uma nova matriz contendo os elementos que foram removidos.

Por motivos de integridade, aqui estão as funções. Primeiro função remove ocorrência única único (isto é, a remoção do primeiro jogo 5de [2,5,9,1,5,8,5]), enquanto a segunda função remove todas as ocorrências:

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

Não sei como você espera array.remove(int)se comportar. Existem três possibilidades em que posso pensar que você pode querer.

Para remover um elemento de uma matriz em um índice i:

array.splice(i, 1);

Se você deseja remover todos os elementos com valor numberda matriz:

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

Se você apenas deseja que o elemento no índice inão exista mais, mas não deseja que os índices dos outros elementos sejam alterados:

delete array[i];

Editado em outubro de 2016

• Faça de forma simples, intuitiva e explícita (a navalha de Occam )
• Imutável (a matriz original permanece inalterada)
• Faça isso com funções JavaScript padrão, se o seu navegador não as suportar - use polyfill

Neste exemplo de código, uso a função "array.filter (...)" para remover itens indesejados de uma matriz. Esta função não altera a matriz original e cria uma nova. Se o seu navegador não suportar esta função (por exemplo, Internet Explorer antes da versão 9 ou Firefox antes da versão 1.5), considere usar o polyfill de filtro do Mozilla .

Removendo item (código ECMA-262 Edition 5, também conhecido como JavaScript à moda antiga)

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 ]

Removendo item (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 A sintaxe da função de seta ECMAScript 6 "() => {}" não é suportada no Internet Explorer, Chrome antes da versão 45, Firefox antes da versão 22 e Safari antes da versão 10. Para usar a sintaxe do ECMAScript 6 em navegadores antigos, você pode usar o BabelJS .

Removendo vários itens (código ECMAScript 7)

Uma vantagem adicional desse método é que você pode remover vários itens

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 ]

A função "array.includes (...)" IMPORTANTE não é suportada no Internet Explorer, Chrome antes da versão 47, Firefox antes da versão 43, Safari antes da versão 9 e Safari antes da versão 9 e Edge antes da versão 14, então aqui está o polyfill do Mozilla .

Removendo vários itens (no futuro, talvez)

Se a proposta "Esta sintaxe de ligação" for aceita, você poderá fazer o seguinte:

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

Tente você mesmo no BabelJS :)

Referência

• Array.prototype.includes
• Composição funcional

Depende se você deseja manter um local vazio ou não.

Se você deseja um slot vazio, a exclusão está correta:

delete array[index];

Caso contrário, use o método de emenda :

array.splice(index, 1);

E se você precisar do valor desse item, poderá apenas armazenar o elemento da matriz retornada:

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

Caso deseje fazer isso em alguma ordem, você pode usar array.pop()para o último ou array.shift()para o primeiro (e ambos retornam o valor do item também).

E se você não souber o índice do item, poderá usá array.indexOf(item)-lo (em um if()para obter um item ou em um while()para obter todos eles). array.indexOf(item)retorna o índice ou -1 se não for encontrado. 

Um amigo estava com problemas no Internet Explorer 8 e me mostrou o que ele fez. Eu disse a ele que estava errado, e ele me disse que conseguiu a resposta aqui. A resposta superior atual não funcionará em todos os navegadores (Internet Explorer 8, por exemplo) e somente removerá a primeira ocorrência do item.

Remova todas as instâncias de uma matriz

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

Ele percorre a matriz para trás (uma vez que os índices e o comprimento mudam à medida que os itens são removidos) e remove o item, se encontrado. Funciona em todos os navegadores.

Existem duas abordagens principais:

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

2. delete :delete anArray[index];

Tenha cuidado ao usar excluir para uma matriz. É bom para excluir atributos de objetos, mas não tão bom para matrizes. É melhor usar splicepara matrizes.

Lembre-se de que, quando você usa deleteuma matriz, pode obter resultados errados anArray.length. Em outras palavras, deleteremoveria o elemento, mas não atualizaria o valor da propriedade length.

Você também pode esperar ter buracos nos números de índice depois de usar a exclusão, por exemplo, pode acabar tendo os índices 1, 3, 4, 8, 9 e 11 e comprimento como eram antes de usar a exclusão. Nesse caso, todos os forloops indexados travariam, pois os índices não são mais seqüenciais.

Se você for forçado a usar deletepor algum motivo, deverá usar for eachloops quando precisar percorrer matrizes. Na verdade, sempre evite usar forloops indexados , se possível. Dessa forma, o código seria mais robusto e menos propenso a problemas com í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);

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)

Não há necessidade de usar indexOfou splice. No entanto, ele funciona melhor se você deseja remover apenas uma ocorrência de um elemento.

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

Uso indexOfe splice(índice):

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

Use apenas splice(emenda):

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

Tempos de execução em nodejs para matriz com 1000 elementos (média acima de 10000 execuções):

indexof é aproximadamente 10x mais lento que o movimento . Mesmo se melhorou, removendo a chamada para indexOfa emenda ele executa muito pior do movimento .

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

Isso fornece um predicado em vez de um valor.

NOTA: ele atualiza a matriz especificada e retorna as linhas afetadas.

Uso

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

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

Definição

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

Você pode fazer isso facilmente com o método de filtro :

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

Isso remove todos os elementos da matriz e também funciona mais rápido que uma combinação de slicee indexOf.

John Resig postou uma boa implementação :

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

Se você não deseja estender um objeto global, pode fazer algo como o seguinte:

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

Mas a principal razão pela qual estou postando isso é alertar os usuários contra a implementação alternativa sugerida nos comentários nessa página (14 de dezembro 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 bem no começo, mas através de um processo doloroso, descobri que ele falha ao tentar remover o penúltimo elemento de uma matriz. Por exemplo, se você tiver uma matriz de 10 elementos e tentar remover o 9º elemento com isso:

myArray.remove(8);

Você acaba com uma matriz de 8 elementos. Não sei por que, mas confirmei que a implementação original de John não tem esse problema.

O Underscore.js pode ser usado para resolver problemas com vários navegadores. Ele usa métodos de navegador embutidos, se presentes. Se estiverem ausentes, como no caso de versões mais antigas do Internet Explorer, ele usa seus próprios métodos personalizados.

Um exemplo simples para remover elementos da matriz (do site):

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

Você pode usar o ES6. Por exemplo, para excluir o valor '3' neste caso:

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

Resultado :

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

Se você deseja remover uma nova matriz com as posições excluídas, sempre pode excluir o elemento específico e filtrar a matriz. Pode ser necessário uma extensão do objeto de matriz para navegadores que não implementam o método de filtro, mas a longo prazo é mais fácil, pois tudo o que você faz é o seguinte:

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

Deve aparecer [1, 2, 3, 4, 6].

Confira este código. Funciona em todos os principais navegadores .

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

Chame esta função

remove_item(array,value);

Você pode usar lodash _.pull (mutate array), _.pullAt (mutate array) ou _.without (não muda o 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']

ES6 e sem mutação: (outubro 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)

A remoção de um elemento / string específico de uma matriz pode ser feita em uma única linha:

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

Onde:

theArray : a matriz da qual você deseja remover algo específico

stringToRemoveFromArray : a string que você deseja remover e 1 é a quantidade de elementos que você deseja remover.

NOTA : Se "stringToRemoveFromArray" não estiver localizado na sua matriz, isso removerá o último elemento da matriz.

É sempre uma boa prática verificar se o elemento existe em sua matriz primeiro, antes de removê-lo.

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

Se você tiver acesso a versões mais recentes do Ecmascript nos computadores do seu cliente (AVISO, pode não funcionar em estações mais antigas):

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

Onde '3' é o valor que você deseja remover da matriz. A matriz se tornaria:['1','2','4','5','6']

Aqui estão algumas maneiras de remover um item de uma matriz usando JavaScript .

Todo o método descrito não altera a matriz original e cria uma nova.

Se você conhece o índice de um item

Suponha que você tenha uma matriz e deseje remover um item na posição i.

Um método é 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()cria uma nova matriz com os índices que recebe. Simplesmente criamos uma nova matriz, do início ao índice que queremos remover e concatenamos outra matriz da primeira posição após a que removemos até o final da matriz.

Se você conhece o valor

Nesse caso, uma boa opção é usar filter(), que oferece uma abordagem mais declarativa :

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

console.log(filteredItems)

Isso usa as funções de seta do ES6. Você pode usar as funções tradicionais para oferecer suporte a navegadores mais antigos:

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

console.log(filteredItems)

ou você pode usar o Babel e transpilar o código ES6 de volta para o ES5 para torná-lo mais digerível para navegadores antigos e, ainda assim, escrever o JavaScript moderno em seu código.

Removendo vários itens

E se, em vez de um único item, você desejar remover muitos itens?

Vamos encontrar a solução mais simples.

Por índice

Você pode apenas criar uma função e remover itens em série:

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

Você pode procurar por inclusão dentro da função de retorno de chamada:

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 alterar a matriz original

splice()(para não confundir slice()) modifica a matriz original e deve ser evitada.

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

OK, por exemplo, você tem a matriz abaixo:

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

E queremos excluir o número 4. Você pode simplesmente usar o código abaixo:

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

Se você estiver reutilizando essa função, escreva uma função reutilizável que será anexada à função de matriz nativa como abaixo:

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

Mas e se você tiver a matriz abaixo com alguns [5] s na matriz?

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

Precisamos de um loop para verificar todos eles, mas uma maneira mais fácil e eficiente é usar funções JavaScript integradas, por isso escrevemos uma função que usa um filtro como o abaixo:

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]

Além disso, existem bibliotecas de terceiros que ajudam você a fazer isso, como Lodash ou Underscore. Para obter mais informações, consulte lodash _.pull, _.pullAt ou _.without.

Eu sou muito novo em JavaScript e precisava dessa funcionalidade. Eu apenas escrevi isso:

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

Então, quando eu quero usá-lo:

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

Saída - conforme o esperado. ["item1", "item1"]

Você pode ter necessidades diferentes das que eu, para poder modificá-las facilmente para atender a elas. Espero que isso ajude alguém.

Se você tiver objetos complexos na matriz, poderá usar filtros? Em situações em que $ .inArray ou array.splice não é tão fácil de usar. Especialmente se os objetos forem rasos na matriz.

Por exemplo, se você tem um objeto com um campo Id e deseja que o objeto seja removido de uma matriz:

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

Quero responder com base no ECMAScript 6 . Suponha que você tenha uma matriz como abaixo:

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

Se você deseja excluir em um índice especial como 2, escreva o código abaixo:

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

Mas se você deseja excluir um item especial como 3e não conhece seu índice, faça o seguinte:

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

Dica : use uma função de seta para o retorno de chamada do filtro, a menos que você obtenha uma matriz vazia.

Atualização: este método é recomendado apenas se você não puder usar o ECMAScript 2015 (anteriormente conhecido como ES6). Se você pode usá-lo, outras respostas aqui fornecem implementações muito mais claras.

Essa essência aqui resolverá seu problema e também excluirá todas as ocorrências do argumento em vez de apenas 1 (ou um 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]

atuação

Hoje (09/09/2019) realizo testes de desempenho no macOS v10.13.6 (High Sierra) para as soluções escolhidas. eu mostrodelete (A), mas não o uso em comparação com outros métodos, porque deixou espaço vazio na matriz.

As conclusões

• a solução mais rápida é array.splice(C) (exceto o Safari para pequenas matrizes em que ocorre pela segunda vez)
• para grandes matrizes, array.slice+splice(H) é a solução imutável mais rápida para Firefox e Safari; Array.from(B) é o mais rápido no Chrome
• soluções mutáveis ​​são geralmente 1,5x-6x mais rápidas que imutáveis
• para pequenas tabelas no Safari, surpreendentemente a solução mutável (C) é mais lenta que a solução imutável (G)

Detalhes

Nos testes, removo o elemento do meio da matriz de maneiras diferentes. As soluções A, C estão em vigor. As soluções B, D, E, F, G, H são imutáveis.

Resultados para array com 10 elementos

No Chrome, o array.splice(C) é a solução local mais rápida. O array.filter(D) é a solução imutável mais rápida. O mais lento é array.slice(F). Você pode executar o teste em sua máquina aqui .

Resultados para array com 1.000.000 elementos

No Chrome, o array.splice(C) é a solução mais rápida no local (o delete(C) é semelhante rapidamente - mas deixou um slot vazio na matriz (para não executar uma 'remoção completa')). O array.slice-splice(H) é a solução imutável mais rápida. O mais lento é array.filter(D e E). Você pode executar o teste em sua máquina aqui .

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.

Comparação para navegadores: Chrome v78.0.0, Safari v13.0.4 e Firefox v71.0.0

Você nunca deve alterar sua matriz. Como isso é contra o padrão de programação funcional. Você pode criar uma nova matriz sem fazer referência à matriz da qual deseja alterar os dados usando o método ECMAScript 6 filter;

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

Suponha que você queira remover 5da matriz, basta fazê-lo da seguinte maneira:

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

Isso fornecerá uma nova matriz sem o valor que você deseja remover. Então o resultado será:

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

Para um maior entendimento, você pode ler a documentação do MDN em Array.filter .

Uma abordagem mais moderna do ECMAScript 2015 (anteriormente conhecida como Harmony ou ES 6). Dado:

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

Então:

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

Produzindo:

[1, 2, 4]

Você pode usar o Babel e um serviço de polyfill para garantir que isso seja bem suportado nos navegadores.

Você tem 1 a 9 na matriz e deseja remover 5. Use o código abaixo:

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

Se você deseja vários valores. Exemplo: - 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);

Se você deseja remover um valor de matriz em uma matriz. Exemplo: [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);

Inclui navegador suportado é link .

Sei que já existem muitas respostas, mas muitas parecem complicar demais o problema. Aqui está uma maneira simples e recursiva de remover todas as instâncias de uma chave - chama auto até que o índice não seja encontrado. Sim, ele funciona apenas em navegadores com indexOf, mas é simples e pode ser facilmente preenchido com polyfilled.

Função 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 protótipo

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

    if(index === -1) return;

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

Você pode fazer um loop para trás para garantir que não estrague os índices, se houver várias instâncias do 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);
}

Demonstração ao vivo