web-dev-qa-db-pt.com

Como faço para remover um elemento particular de uma matriz em JavaScript?

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

Existe uma maneira simples de remover um elemento específico de uma matriz? O equivalente a algo como array.remove(number);.

Eu tenho que usar core JavaScript - no frameworks são permitidos.

6816
Walker

Encontre a index do elemento da matriz que você deseja remover e remova esse índice com splice .

O método splice () altera o conteúdo de um array removendo Elementos existentes e/ou adicionando novos elementos.

var array = [2, 5, 9];
console.log(array)
var index = array.indexOf(5);
if (index > -1) {
  array.splice(index, 1);
}
// array = [2, 9]
console.log(array);

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

9908
Tom Wadley

Eu não sei como você está esperando que array.remove(int) se comporte. Há três possibilidades que posso pensar que você pode estar querendo.

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

array.splice(i, 1);

Se você quiser remover todos os elementos com o valor number da matriz:

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

Se você quiser apenas fazer com que o elemento no índice i não exista mais, mas você não quer que os índices dos outros elementos sejam alterados:

delete array[i];
1011
Peter Olson

Editado em 2016 outubro

  • Simples, intuitivo e explícito ( https://en.wikipedia.org/wiki/Occam%27s_razor )
  • Faça-o imutável (matriz original permanece inalterada)
  • Faça isso com as funções JS padrão, se o seu navegador não as suporta - use polyfill

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

Removendo o item (código ECMA-262 Edição 5, conhecido como oldstyle JS)

var value = 3

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

arr = arr.filter(function(item) { 
    return item !== value
})

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

Removendo item (código ES2015)

let value = 3

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

arr = arr.filter(item => item !== value)

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

IMPORTANT ES2015 "() => {}" A sintaxe da função de seta não é suportada no IE, Chrome antes da versão 45, Firefox antes da versão 22, Safari antes da versão 10. Para usar a sintaxe do ES2015 em navegadores antigos, você pode usar BabelJS


Removendo vários itens (código ES2016)

Uma vantagem adicional deste 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 ]

IMPORTANT "array.includes (...)" a função não é suportada em IE, o Chrome antes da versão 47, o Firefox antes da versão 43, o Safari antes da versão 9 e o Edge antes da versão 14 aqui é o polyfill do Mozilla

Removendo vários itens (JavaScript experimental de ponta ES2018?)

// array-lib.js

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

// main.js

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

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

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

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

Tente você mesmo em BabelJS :)

Referência

831
Ujeenator

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

Se você quer um slot vazio, delete está bem:

delete array[ index ];

Se você não fizer isso, você deve usar o método splice :

array.splice( index, 1 );

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

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

Caso você queira 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, você pode usar array.indexOf( item ) para obtê-lo (em uma if() para obter um item ou em while() para obter todos eles). array.indexOf( item ) retorna o índice ou -1 se não for encontrado.

383
xavierm02

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

Remover TODAS as instâncias de um array

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

Ele percorre a matriz de trás para frente (desde que os índices e o tamanho serão alterados à medida que os itens são removidos) e remove o item, se ele for encontrado. Funciona em todos os navegadores.

251
Ben Lesh

Existem duas abordagens principais:

  1. splice (): 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 bons para matrizes. É melhor usar splice para matrizes.

Tenha em mente que quando você usa delete para uma matriz, você pode obter resultados errados para anArray.length. Em outras palavras, delete removeria 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, você pode acabar tendo índices 1,3,4,8,9,11 e o comprimento como estava antes de usar o delete. Nesse caso, todos os loops for indexados travariam, já que os índices não são mais sequenciais.

Se você for forçado a usar delete por alguma razão, então você deve usar for each loops quando você precisa fazer um loop através de matrizes. De fato, sempre evite usar loops indexados, se possível. Dessa forma, o código seria mais robusto e menos propenso a problemas com índices.

142
Sasa
Array.prototype.remByVal = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] === val) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
}
//Call like
[1, 2, 3, 4].remByVal(3);

Array.prototype.remByVal = function(val) {
    for (var i = 0; i < this.length; i++) {
        if (this[i] === val) {
            this.splice(i, 1);
            i--;
        }
    }
    return this;
}

var rooms = ['hello', 'something']

rooms = rooms.remByVal('hello')

console.log(rooms)

118
Zirak

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

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

Use indexOf e splice (indexof):

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

Use somente splice (splice):

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 move. Mesmo se melhorado, removendo a chamada para indexOf em splice, ele executa muito pior que move

Remove all occurrences:
    move 0.0048 ms
    indexof 0.0463 ms
    splice 0.0359 ms

Remove first occurrence:
    move_one 0.0041 ms
    indexof_one 0.0021 ms
87
slosd

Demasiado velho para responder, mas pode ajudar alguém, fornecendo um predicado em vez de um valor.

NOTA: ele atualizará a matriz fornecida e retornará 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;
    }
};
59
amd

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 quiser estender um objeto global, poderá fazer algo como o seguinte, em vez disso:

// 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 é para 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 eu descobri que ele falha ao tentar remover o segundo para o último elemento em uma matriz. Por exemplo, se você tiver uma matriz de 10 elementos e tentar remover o 9º elemento com isto:

myArray.remove(8);

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

56
Roger

Underscore.js pode ser usado para resolver problemas com vários navegadores. Ele usa métodos de navegador embutido, se presentes. Se eles 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]
54
vatsal

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

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 do que a combinação de fatia e indexOf

53
Salvador Dali

Se você quiser que uma nova matriz com as posições excluídas seja removida, você sempre poderá excluir o elemento específico e filtrar a matriz. Pode precisar de uma extensão do objeto array para navegadores que não implementam o método de filtro, mas no longo prazo é mais fácil, já que tudo que você faz é isto:

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 exibir [1, 2, 3, 4, 6]

42
Loupax

Você pode usar o ES6. 

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

Saída: 

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

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

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

Chame essa função 

remove_item(array,value);
35
Ekramul Hoque

Você pode usar lodash _.pull (matriz mutate), _.pullAt (matriz mutate) ou _.without (não faz a matriz mutate), 

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

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

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

OK, por exemplo, você está tendo o array abaixo:

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

E nós queremos excluir o número 4, você pode simplesmente fazer o código abaixo:

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

Se você reutilizar esta função, você escreverá 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 o array abaixo em vez de alguns [5] s no Array?

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

Precisamos de um loop para verificar todos eles, mas a maneira mais fácil e eficiente é usar funções JavaScript integradas, então escrevemos uma função que usa filtro como 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 o ajudam a fazer isso, como o Lodash ou o Underscore, para mais informações, veja o lodash _.pull, _.pullAt ou o _.without.

32
Alireza

Sou novo em JavaScript e precisava dessa funcionalidade. Eu simplesmente escrevi isso:

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

Então quando eu quiser 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 esperado. ["Item1", "item1"]

Você pode ter necessidades diferentes de mim, então você pode modificá-lo facilmente para se adequar a elas. Espero que isso ajude alguém.

27
sofiax

ES6 e sem mutação: (outubro de 2016)

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

Então : 

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

Update: Este método é recomendado somente se você não puder usar o ECMAScript 2015 (anteriormente conhecido como ES6). Se você puder usá-lo, outras respostas aqui fornecem implementações muito mais nítidas.


Esta essência aqui irá resolver o seu problema, e também elimina 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]
22
zykadelic

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

Por exemplo. se você tiver um objeto com um campo Id e quiser que o objeto seja removido de uma matriz:

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

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

Todo o método descrito não muta a matriz original e, em vez disso, cria um novo.

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-1).concat(items.slice(i, items.length))

console.log(filteredItems)

slice() cria uma nova matriz com os índices que recebe. Nós 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 suportar 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 escrever JavaScript moderno em seu código.

Removendo vários itens

E se, em vez de um único item, você quiser 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 mudar o array original

splice() (não confunda com slice()) muda o array original e deve ser evitado.

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

20
Flavio Copes

Você nunca deve transformar seu array em array. Como isso é contra o padrão de programação funcional. O que você pode fazer é criar uma nova matriz sem fazer referência à matriz que deseja alterar os dados usando o método es6 filter;

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

Suponha que você queira remover 5 da matriz, você pode simplesmente fazer assim.

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 entender melhor, você pode ler a documentação do MDN em Array.filter https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

19
Adeel Imran

Uma abordagem mais moderna, ECMAScript 2015 (anteriormente conhecida como Harmonia 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 polyfill para garantir que isso seja bem suportado em todos os navegadores.

18
bjfletcher

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

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

Eu tenho outra boa solução para remover de uma 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/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

15
Aram Grigoryan

Você pode fazer um loop para trás para certificar-se de não estragar 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

15
Jeff Noel

Com base em todas as respostas que estavam corretas e levando em consideração as melhores práticas sugeridas (especialmente não usando o Array.prototype diretamente), eu criei o código abaixo:

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

Revendo a função acima, apesar do fato de que funciona bem, percebi que poderia haver alguma melhora no desempenho. Também usar ES6 em vez de ES5 é uma abordagem muito melhor. Para esse fim, esse é o código aprimorado:

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

Como usar:

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)

No momento, estou escrevendo um post de blog no qual testei várias soluções para o Array sem problemas e comparei o tempo necessário para executá-las. Eu atualizarei esta resposta com o link assim que terminar esse post. Só para você saber, eu comparei o acima contra o da Lodash sem e no caso do navegador suporta Map, ele bate lodash! Observe que não estou usando Array.prototype.indexOf ou Array.prototype.includes como agrupar os exlcudeValues ​​em uma Map ou Object torna a consulta mais rápida!

15
Ardi

Você tem 1 a 9 array e você quer remover 5 use abaixo do 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);


Se você quiser um valor múltiplo ex: - 1,7,8

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

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

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


Se você quiser remover o valor da matriz na matriz ex: - [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

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

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

Remover por índice

Função que retorna uma cópia da matriz sem o elemento no í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 ]

Remover por valor

Função que retorna uma cópia da matriz sem o valor.

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

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

Eu quero responder com base emES6. Suponha que você tenha uma matriz como abaixo:

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

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

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

Mas se você quer deletar um item especial como 3 e não sabe o seu índice como abaixo:

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

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

11
AmerllicA

Criar nova matriz:

var my_array = new Array();

Adicione elementos a este array:

my_array.Push("element1");

A função indexOf (retorna o índice ou -1 quando não encontrado):

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

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

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

Verifique o índice desse elemento (testado com o firefox e o IE8 +):

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

Remover 1 elemento localizado no índice da matriz

my_array.splice(index, 1);
11
Enrico

Eu também corri na situação em que eu tinha que remover um elemento de Array. .indexOf não estava funcionando em IE* para compartilhar minha solução jQuery.inArray() de trabalho.

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

2017-05-08

A maioria das respostas dadas funciona para comparação estrita, o que significa que os dois objetos fazem referência ao mesmo objeto exato na memória (ou são tipos primitivos), mas geralmente você deseja remover um objeto não primitivo de uma matriz que possui um determinado valor. Por exemplo, se você fizer uma chamada para um servidor e quiser verificar um objeto recuperado em um 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}]

Existem implementações alternativas/rápidas para valuesAreEqual, mas isso faz o trabalho. Você também pode usar um comparador personalizado se tiver um campo específico para verificar (por exemplo, algum UUID recuperado versus um UUID local).

Observe também que esta é uma operação funcional, o que significa que ela não altera o array original.

9
Aidan Hoolachan

Eu acho que muitas das instruções de JavaScript não são bem pensadas para programação funcional. Splice retorna o elemento excluído onde na maioria das vezes você precisa da matriz reduzida. Isto é mau.

Imagine que você está fazendo uma chamada recursiva e precisa passar uma matriz com um item a menos, provavelmente sem o item indexado atual. Ou imagine que você esteja fazendo outra chamada recursiva e passe por uma matriz com um elemento pressionado.

Em nenhum destes casos você pode fazer myRecursiveFunction(myArr.Push(c)) ou myRecursiveFunction(myArr.splice(i,1)). O primeiro idiota de fato passará o tamanho da matriz e o segundo idiota passará o elemento deletado como um parâmetro.

Então, o que eu faço de fato ... Para excluir um elemento de matriz e passando o resultado para uma função como um parâmetro ao mesmo tempo eu faço o seguinte

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

Quando se trata de empurrar isso é mais bobo ... eu gosto,

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

Acredito que em uma linguagem funcional adequada, um método que muda o objeto para o qual ele é chamado deve retornar uma referência ao próprio objeto como resultado.

9
Redu

Em CoffeeScript :

my_array.splice(idx, 1) for ele, idx in my_array when ele is this_value
8
Nigel Sheridan-Smith

Use o InArray do jQuery:

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

Nota: inArray retornará -1, se o elemento não foi encontrado.

7
Do Hoa Vinh

Vanilla JavaScript (ES5.1) - no lugar edition

Suporte do navegador: Internet Explorer 9 ou posterior ( suporte detalhado do 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;
}

Vanilla JavaScript (ES5.1) - imutável edição

Suporte ao navegador: O mesmo que o Vanilla JavaScript na edição local

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

    arrayCopy = array.slice();

    return removeInPlace(arrayCopy, item);
}

Vanilla ES6 - imutável edição

Suporte ao navegador: Chrome 46, Edge 12, Firefox 16, Opera 37, Safari 8 ( suporte detalhado ao 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;
}
6
Lars Gyrup Brink Nielsen
[2,3,5].filter(i => ![5].includes(i))
6
Atchutha rama reddy Karri

Remova o elemento no índice i, sem alterar o array original:

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

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

Eu gosto desta versão da emenda, removendo um elemento pelo seu valor usando $.inArray:

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

Você pode iterar sobre cada array- item e splice se ela existir na sua array.

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

Acabei de criar um polyfill no Array.prototype via Object.defineProperty para remover um elemento desejado em uma matriz sem causar erros ao iterar mais tarde via for .. in ..

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

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

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

Removendo um valor inteiro

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

Removendo um valor de string

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

Removendo um valor booleano

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

Também é possível remover um objeto dentro da matriz através deste método Array.prototype.remove. Você só precisa especificar o key => value da Object que deseja remover.

Removendo um valor de objeto

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

Eu fiz uma extensão bastante eficiente para o array JavaScript de base:

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

Pela minha solução, você pode remover um ou mais de um item em uma matriz, graças ao JavaScript puro. Não há necessidade de outra biblioteca JavaScript.

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

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

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

Remover um valor, usando comparação solta, sem alterar o array original, ES6

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

Ainda outra resposta, para mim, quanto mais simples melhor, e como estamos em 2018 (perto de 2019), dou-lhe este (próximo) um forro para responder à pergunta original:

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

O útil é que você pode usá-lo em uma expressão curry como:

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

4
Sebastien H.

Embora a maioria das respostas acima responda à pergunta, não está claro o motivo pelo qual o método slice() não foi usado. Sim, filter() atende aos critérios de imutabilidade, mas que tal fazer o seguinte equivalente mais curto:

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

E agora vamos dizer que devemos remover o segundo elemento da matriz, podemos simplesmente fazer: const newArray = myArray.slice(0,1).concat(myArray.slice(2,4));// [1,3,4]

Essa forma de excluir um elemento de uma matriz é fortemente incentivada hoje na comunidade devido à sua natureza simples e imutável. Em geral, métodos que causam mutação devem ser evitados. Por exemplo, você é encorajado a substituir Push() por concat() e splice() por slice() 

4
Stelios Voskos

Use jQuery.grep () :

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

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

4
Mahendra Kulkarni

Remover um determinado elemento/string de uma matriz pode ser feito em um único liner: Eu ainda acho que este é o mais elegante forro que você pode obter para este tipo de problema: 

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

onde 'theArray' é o array do qual você deseja remover algo particular.

4
Max Alexander Hanna

Poste meu código que remove um elemento da matriz e reduza também o tamanho da matriz.

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

Há muitas respostas fantásticas aqui, mas para mim, o que funcionou mais simplesmente não foi remover o meu elemento da matriz completamente, mas simplesmente defini-lo como nulo. Isso funciona para a maioria dos casos que tenho, e é uma boa solução, já que vou usar a variável mais tarde e não quero que ela desapareça, apenas vazia por enquanto. Além disso, essa abordagem é totalmente compatível com vários navegadores.

array.key = null;
3
rncrtr

Remover última ocorrência ou todas as ocorrências ou primeira ocorrência? 

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

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

ou

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

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

Para qualquer pessoa que queira replicar um método que retornará uma nova matriz que tenha números ou cadeias de caracteres duplicados removidos, isso foi reunido a partir de respostas existentes:

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

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

  console.log(tempObj);

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

  return dupFree;
}
3
cjjenkinson

Fiz uma função 

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

E usado assim.

pop(valuetoremove,myarray);

Felicidades!

3
Ali Akram

Implementação muito ingênua seria a seguinte:

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

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

Retorno o comprimento da matriz da função para obedecer a outros métodos, como Array.prototype.Push().

3
Gaurang Patel

Eu tive esse problema eu mesmo (em uma situação em que a substituição do array era aceitável) e resolvi isso de uma forma simples:

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

Para dar ao trecho acima um pouco de contexto:

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

            this.items = filteredItems;
        }
    };

Essa solução deve funcionar com itens de referência e valor. Tudo depende se você precisa manter uma referência ao array original para saber se esta solução é aplicável. 

2
Phil

Muitas vezes é melhor apenas criar uma nova matriz com a função de filtro.

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

Isso também melhora a capacidade de leitura. Eu não sou fã de fatia, embora saiba que às vezes você deve ir para ela.

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

Usando o Array.findindex, podemos reduzir o número de linhas de código.

developer.mozilla.org

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

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

Esta solução terá uma matriz de entrada e pesquisará a entrada para o valor a ser removido. Isso fará um loop por todo o array de entrada e o resultado será um segundo inteiro de matriz que teve o índice específico removido. A matriz de inteiros é então copiada de volta na matriz de entrada. 

2
penguin

Sua pergunta não indicou se a ordem ou os valores distintos são um requisito.

Se você não se importa com a ordem e não terá o mesmo valor no contêiner mais de uma vez, use um conjunto. Será muito mais rápido e mais sucinto. 

var aSet = new Set();

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

aSet.delete(2);
2
Steven Spungin

Removendo o valor com índice e emenda!

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

excluir elemento do último 

arrName.pop();

delete element from first 

arrName.shift();

excluir do meio

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

Ex: arrName.splice(1,1);

excluir um elemento da última

arrName.splice(-1);

Excluir usando o número do índice da matriz

 delete arrName[1];
2
Srikrushna Pal

Que vergonha você tem uma matriz de inteiros, não um objeto onde as chaves são equivalentes de seqüência desses números inteiros.

Eu examinei muitas dessas respostas e todas elas parecem usar "força bruta" até onde eu posso ver. Eu não examinei cada um, desculpas se isso não é verdade. Para um array pequeno isso é bom, mas e se você tiver milhares de inteiros nele?

Corrija-me se estiver errado, mas não podemos assumir que em um mapa key => value, do tipo que é um objeto JS, o mecanismo de recuperação de chave pode ser considerado altamente projetado e otimizado? (Nota: se algum super especialista me disser que este não é o caso, posso sugerir o uso da classe Map - do ES6 , que certamente será).

Estou apenas sugerindo que, em certas circunstâncias, a melhor solução seria converter sua matriz em um objeto ... o problema é que, é claro, você pode ter repetido valores inteiros. Sugiro colocá-los em blocos como a parte "valor" das entradas key => value. (Nota: se você tiver certeza de que não tem nenhum elemento de array repetitivo, isso pode ser muito mais simples: valores "iguais a", e apenas Object.values(...) para recuperar o array modificado).

Então você poderia fazer:

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

console.log( myIntsMapObj );

saída:

Objeto [<1 slot vazio>, Matriz 1 , Matriz [2], Matriz 1 , Matriz 1 , <5 Slots vazios>, 46 mais…]

então é fácil excluir todos os números 55

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

Você não precisa excluir todos eles: os valores do índice são colocados em seus blocos na ordem da aparência, portanto (por exemplo):

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

irá apagar a primeira e a última ocorrência, respectivamente. Você pode contar a frequência de ocorrência facilmente, substituir todos os 55s por 3s, transferindo o conteúdo de um balde para outro, etc.

... voltar a sua matriz int modificada é um pouco envolvida: mas cada bucket contém o índice (na matriz original) do valor representado pela chave (string). Cada um desses valores de bucket também é exclusivo: assim, você os transforma em chaves em um novo objeto, com o inteiro (real) da "chave de cadeia inteira" como valor ... depois, classifique as chaves e vá para Object.values( ... ).

Isso parece muito complicado e demorado ... mas obviamente tudo depende das circunstâncias e do uso desejado. Meu entendimento é que todas as versões e contextos de JS operam apenas em um thread, e o thread não "solta", então pode haver algum congestionamento horrível com um método de "força bruta": causado não tanto pelas ops do indexOf , mas várias repetidas slice/splice ops.

Termo aditivo
Se você é certo isso é engenharia demais para seu caso de uso, certamente a abordagem mais simples de "força bruta" é

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

(sim, outras respostas detectaram Array.prototype.filter...)

2
mike rodent

O método a seguir removerá todas as entradas de um determinado valor de uma matriz sem criar uma nova matriz e com apenas uma iteração que é superfast. E funciona no antigo navegador Internet Explorer 5.5 :

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

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

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

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

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

removeFromArray(a, 0);

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

2
Eugene Tiurin

Para remover um determinado elemento ou elementos subsequentes, o método Array.splice () funciona bem. O método splice () altera o conteúdo de um array removendo ou substituindo elementos existentes e/ou adicionando novos elementos e ele retorna o (s) item (ns) removido (s).

Sintaxe: _ ​​array.splice (index, deleteCount, item1, ....., itemX)

Aqui index é obrigatório e os argumentos de descanso são opcionais.

Por exemplo:

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

Nota:Array.splice () método pode ser usado se você souber o índice do elemento que você deseja excluir. Mas podemos ter mais alguns casos, conforme mencionado abaixo-

  1. Caso você queira excluir apenas o último elemento, você pode usar Array.pop ()

  2. Caso você queira excluir apenas o primeiro elemento, você pode usar Array.shift ()

  3. Se você conhece o elemento sozinho, mas não a posição (ou índice) do elemento, e deseja excluir todos os elementos correspondentes usando Array.filter () method:

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

OU usando o método splice ()

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

OU Suponha que queremos excluir del da matriz Array:

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

OR

let del = 4;
for(var i = arr.length - 1; i >= 0; i--) {
    if(arr[i] === del) {
       arr.splice(i, 1);
    }
}
  1. Se você conhece o elemento sozinho, mas não a posição (ou índice) do elemento, e deseja excluir apenas o primeiro elemento correspondente usando o método splice ():

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

Se você deve oferecer suporte a versões mais antigas do Internet Explorer, recomendo usar o seguinte polyfill (observação: isso é not uma estrutura). É uma substituição 100% compatível com todos os métodos de array modernos (JavaScript 1.8.5/ECMAScript 5 Array Extras) que funciona para o Internet Explorer 6+, Firefox 1.5+, Chrome, Safari e Opera.

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

1
Matt Brock

Defina um método chamado remove () em objetos de matriz usando o recurso de prototipagem do JavaScript.

Use o método splice () para atender a sua exigência.

Por favor, dê uma olhada no código abaixo.

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

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

    return index;
}


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

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

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

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

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

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

Nota: Abaixo está o código de exemplo completo executado em Node.js REPL que descreve o uso de Push (), pop (), shift (), unshift () e splice () métodos.

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

Obrigado.

1
hygull

Emparelhar, filtrar e excluir para remover o elemento da matriz

Cada matriz tem seu índice e ajuda a excluir um determinado elemento com seu índice.

O método splice () 

array.splice (index, 1 ); 1º parâmetro é index e segundo é o número de elemento que você

deseja excluir desse índice.

Então, para um único elemento, usamos 1. 

O método delete

delete array [index]

O método filter ()

Se você quiser excluir o elemento que é repetido na matriz, filtre a matriz.

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

onde elem é o elemento que você deseja remover da matriz e array é o nome da sua matriz

1
ashish

O método splice () altera o conteúdo de um array removendo ou substituindo elementos existentes e/ou adicionando novos elementos.

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

start

Índice no qual começar a mudar a matriz (com origem 0). Se for maior que o comprimento da matriz, o índice inicial real será definido para o comprimento da matriz. Se for negativo, começará muitos elementos do final da matriz (com Origin -1) e será definido como 0 se o valor absoluto for maior que o comprimento da matriz.

deleteCount Opcional

Um inteiro indicando o número de elementos antigos da matriz a serem removidos. Se deleteCount for omitido, ou se seu valor for maior que array.length - start (ou seja, se for maior que o número de elementos restantes no array, começando no início), então todos os elementos do início até o final da matriz serão excluídos. Se deleteCount for 0 ou negativo, nenhum elemento será removido. Nesse caso, você deve especificar pelo menos um novo elemento (veja abaixo).

item1, item2, ... Opcional

Os elementos para adicionar à matriz, começando no índice inicial. Se você não especificar nenhum elemento, splice () somente removerá elementos da matriz.

Para mais referene gentilmente passe por:

https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Array/splice

0
ashish

Já existem muitas respostas, mas como ninguém fez isso com um único liner ainda, imaginei mostrar meu método. Ele tira proveito do fato de que a função string.split () removerá todos os caracteres especificados ao criar uma matriz. Aqui está um exemplo: 

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

Neste exemplo, todos os 4 estão sendo removidos da matriz. No entanto, é importante observar que qualquer array contendo o caractere "-" causará problemas com este exemplo. Em suma, fará com que a função join ("-") junte sua string de maneira inadequada. Em tal situação, todas as strings "-" no snipet acima podem ser substituídas por qualquer string que não será usada no array original. Aqui está outro exemplo: 

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

0
Partial Science

Tomando o lucro do método de redução como seguindo:

caso a) se você precisar remover o elemento por índice:

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

case b) se vc precisar remover element pelo valor do elemento (int):

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

Assim, desta forma, podemos retornar uma nova matriz (será uma maneira funcional legal - muito melhor do que usar Push ou emenda) com o elemento removido.

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

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

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

arr.splice(0,1)

console.log(arr)

Saída [2, 3, 4, 5];

0
Shahriar Ahmad