Excluindo elementos da matriz em JavaScript - excluir vs emenda

Question

O que é a diferença entre usar o operador delete sobre o elemento de matriz em vez de usar o método Array.splice ?

Por exemplo:

myArray = ['a', 'b', 'c', 'd'];

delete myArray[1];
//  or
myArray.splice (1, 1);

Por que ainda têm o método de emenda se eu posso excluir elementos do array como eu posso com objetos?

Answer 1

delete excluirá a propriedade do objeto, mas não irá reindexar a matriz ou atualizar seu comprimento. Isso faz com que ele aparece como se ele é indefinido:

> myArray = ['a', 'b', 'c', 'd']
  ["a", "b", "c", "d"]
> delete myArray[0]
  true
> myArray[0]
  undefined

Note que não é de fato definido como o valor undefined, em vez da propriedade é removido da matriz, tornando-o aparecer indefinido. As ferramentas dev Chrome fazer essa distinção clara, imprimindo empty quando o log da matriz.

> myArray[0]
  undefined
> myArray
  [empty, "b", "c", "d"]

myArray.splice(start, deleteCount) realmente remove o elemento, reindexa da matriz, e altera o seu comprimento.

> myArray = ['a', 'b', 'c', 'd']
  ["a", "b", "c", "d"]
> myArray.splice(0, 2)
  ["a", "b"]
> myArray
  ["c", "d"]

Answer 2

Array.remove () Método

John Resig , criador do jQuery criou um método Array.remove muito útil que eu sempre usá-lo em meus projetos.

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

e é aqui alguns exemplos de como ela poderia ser usada:

// Remove the second item from the array
array.remove(1);
// Remove the second-to-last item from the array
array.remove(-2);
// Remove the second and third items from the array
array.remove(1,2);
// Remove the last and second-to-last items from the array
array.remove(-2,-1);

site da John

Answer 3

Por causa de exclusão só remove o objeto do elemento na matriz, o comprimento da matriz não vai mudar. Splice remove o objeto e encurta a matriz.

O código a seguir irá mostrar "a", "b", "indefinido", "d"

myArray = ['a', 'b', 'c', 'd']; delete myArray[2];

for (var count = 0; count < myArray.length; count++) {
    alert(myArray[count]);
}

Considerando que isto irá mostrar "a", "b", "d"

myArray = ['a', 'b', 'c', 'd']; myArray.splice(2,1);

for (var count = 0; count < myArray.length; count++) {
    alert(myArray[count]);
}

Answer 4

Eu tropeçou em esta questão durante a tentativa de compreender como remover todas as ocorrências de um elemento de uma matriz. Aqui está uma comparação de splice e delete para a remoção de todos os 'c' da matriz items.

var items = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'];

while (items.indexOf('c') !== -1) {
  items.splice(items.indexOf('c'), 1);
}

console.log(items); // ["a", "b", "d", "a", "b", "d"]

items = ['a', 'b', 'c', 'd', 'a', 'b', 'c', 'd'];

while (items.indexOf('c') !== -1) {
  delete items[items.indexOf('c')];
}

console.log(items); // ["a", "b", undefined, "d", "a", "b", undefined, "d"]
​

Answer 5

A partir Firefox 1.5> Operadores> Operadores especial> excluir Operador :

Quando você apaga um elemento da matriz, o comprimento da matriz não é afectada. Para exemplo, se você excluir a [3], a [4] é ainda uma [4] e [3] é indefinido. este detém, mesmo se você excluir a última elemento da matriz (de exclusão um [a.length-1]).

Answer 6

splice irá trabalhar com índices numéricos.

enquanto delete pode ser usado contra outro tipo de índices ..

exemplo:

delete myArray['text1'];

Answer 7

É provavelmente também vale a pena mencionar que a emenda só funciona em arrays. (As propriedades do objeto não pode ser invocado para seguir uma ordem consistente.)

Para remover o par de valores-chave de um objeto, de exclusão é realmente o que você quer:

delete myObj.propName;     // , or:
delete myObj["propName"];  // Equivalent.

Answer 8

Como afirmado muitas vezes acima, usando splice() parece ser um ajuste perfeito. Documentação da Mozilla:

O splice() método altera o conteúdo de uma matriz através da remoção de elementos existentes e / ou a adição de novos elementos.

var myFish = ['angel', 'clown', 'mandarin', 'sturgeon'];

myFish.splice(2, 0, 'drum'); 
// myFish is ["angel", "clown", "drum", "mandarin", "sturgeon"]

myFish.splice(2, 1); 
// myFish is ["angel", "clown", "mandarin", "sturgeon"]

Sintaxe

array.splice(start)
array.splice(start, deleteCount)
array.splice(start, deleteCount, item1, item2, ...)

Parâmetros

start

Índice em que começar a mudar a matriz. Se for maior do que o comprimento da matriz, índice inicial real será definido como o comprimento da matriz. Se negativo, começará que muitos elementos a partir do final.

deleteCount

Um inteiro que indica o número de elementos da matriz para remover velhos. Se deleteCount é 0, não há elementos são removidos. Neste caso, você deve especificar pelo menos um elemento novo. Se deleteCount é maior do que o número de elementos deixados na matriz de partida no início, em seguida, todos os elementos, através da extremidade da matriz vai ser suprimido.

Se deleteCount for omitido, deleteCount será igual ao (arr.length - start).

item1, item2, ...

Os elementos para adicionar à matriz, começando no índice início. Se você não especificar quaisquer elementos, splice() só irá remover elementos do array.

Valor de retorno

Uma matriz contendo os elementos excluídos. Se pelo menos um elemento é removida, uma matriz de um elemento é devolvido. Se não há elementos são removidos, uma matriz vazio é retornado.

[...]

Answer 9

Excluir emenda Vs

quando você excluir um item de um array

var arr = [1,2,3,4]; delete arr[2]; //result [1, 2, 3:, 4]
console.log(arr)

quando você emendar

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

em caso de excluir elemento é apagado , mas o índice permanece vazio

enquanto que no caso de splicing elemento é apagado e o índice de elementos de repouso é reduzido em conformidade

Answer 10

excluir age como uma situação não mundo real, ele só remove o item, mas a matriz estadias de comprimento a mesma:

exemplo do terminal node:

> var arr = ["a","b","c","d"];
> delete arr[2]
true
> arr
[ 'a', 'b', , 'd', 'e' ]

Aqui está uma função para remover um item de uma matriz pelo índice, usando slice () , que leva o arr como o primeiro argumento, e o índice do membro que deseja excluir como o segundo argumento. Como você pode ver, ele realmente elimina o membro da matriz, e reduzirá o comprimento de matriz por 1

function(arr,arrIndex){
    return arr.slice(0,arrIndex).concat(arr.slice(arrIndex + 1));
}

O que a função acima faz é pegar todos os membros até o índice, e todos os membros após o índice, e concatena-los juntos, e retorna o resultado.

Aqui está um exemplo usando a função acima como um módulo nó, vendo o terminal será útil:

> var arr = ["a","b","c","d"]
> arr
[ 'a', 'b', 'c', 'd' ]
> arr.length
4 
> var arrayRemoveIndex = require("./lib/array_remove_index");
> var newArray = arrayRemoveIndex(arr,arr.indexOf('c'))
> newArray
[ 'a', 'b', 'd' ] // c ya later
> newArray.length
3

Por favor note que este não irá funcionar um array com dupes nele, porque indexOf ( "c") receberá apenas a primeira ocorrência, e só emendar para fora e remova o primeiro "c" que encontra.

Answer 11

Se você quiser iterate uma grande variedade e elementos seletivamente apagar, que seria caro para ligar para splice () para cada exclusão porque splice () teria que re-índice elementos posteriores de cada vez. Como os arrays são associativas em JavaScript, seria mais eficiente para eliminar os elementos individuais, em seguida, re-índice do array depois.

Você pode fazer isso através da construção de uma nova matriz. por exemplo

function reindexArray( array )
{
       var result = [];
        for( var key in array )
                result.push( array[key] );
        return result;
};

Mas eu não acho que você pode modificar os valores de chave na matriz original, que seria mais eficiente -. Parece que você pode ter que criar uma nova matriz

Note que você não precisa para verificar as entradas "indefinida" como eles realmente não existem e o loop não devolvê-los. É um artefato da matriz de impressão que exibe como indefinido. Eles não parecem existir na memória.

Seria bom se você poderia usar algo como slice () que seria mais rápido, mas não re-índice. Alguém sabe de uma maneira melhor?

---

Na verdade, você provavelmente pode fazê-lo no lugar da seguinte forma que é provavelmente mais eficiente, em termos de performance:

reindexArray : function( array )
{
    var index = 0;                          // The index where the element should be
    for( var key in array )                 // Iterate the array
    {
        if( parseInt( key ) !== index )     // If the element is out of sequence
        {
            array[index] = array[key];      // Move it to the correct, earlier position in the array
            ++index;                        // Update the index
        }
    }

    array.splice( index );  // Remove any remaining elements (These will be duplicates of earlier items)
},

Answer 12

Você pode usar algo como 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';})); // [1,2,3,4,6]

Answer 13

Por que não apenas filtro? Eu acho que é a maneira mais clara de considerar as matrizes em js.

myArray = myArray.filter(function(item){
    return item.anProperty != whoShouldBeDeleted
});

Answer 14

function remove_array_value(array, value) {
    var index = array.indexOf(value);
    if (index >= 0) {
        array.splice(index, 1);
        reindex_array(array);
    }
}
function reindex_array(array) {
   var result = [];
    for (var key in array) {
        result.push(array[key]);
    }
    return result;
}

exemplo:

var example_arr = ['apple', 'banana', 'lemon'];   // length = 3
remove_array_value(example_arr, 'banana');

banana é suprimido e comprimento de matriz = 2

Answer 15

São coisas diferentes que têm finalidades diferentes.

splice é específica da matriz e, quando usado para a eliminação, remove as entradas da matriz e move todas as entradas anteriores-se para preencher a lacuna. (. Ele também pode ser usado para inserir entradas, ou ambos ao mesmo tempo) splice mudará o length da matriz (assumindo que não é uma chamada não-op: theArray.splice(x, 0)).

delete não é específico do array; ele é projetado para uso em objetos: Ele remove uma propriedade (chave / valor par) a partir do objeto que você usá-lo em. Ele aplica-se somente a matrizes porque as matrizes convencionais (por exemplo, não tipificado) em JavaScript não são realmente matrizes em tudo * , eles são objetos com tratamento especial para determinadas propriedades, tais como aqueles cujos nomes são "índices de matriz" (que são definido como nomes de cadeia" ... cujo valor numérico i está no +0 ≤ i < 2^32-1 gama" ) e length. Quando você usa delete para remover uma entrada de matriz, tudo que faz é remover a entrada; ele não se move outras entradas seguindo-o para preencher a lacuna, e assim a matriz se torna "escassa" (tem algumas entradas faltando inteiramente). Não tem nenhum efeito sobre length.

Um par das respostas atuais a esta pergunta incorretamente estado que usando delete "define a entrada para undefined". Isso não é correto. É remove a entrada (propriedade) inteiramente, deixando uma lacuna.

Vamos usar algum código para ilustrar as diferenças:

console.log("Using `splice`:");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
a.splice(0, 1);
console.log(a.length);            // 4
console.log(a[0]);                // "b"

console.log("Using `delete`");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
delete a[0];
console.log(a.length);            // still 5
console.log(a[0]);                // undefined
console.log("0" in a);            // false
console.log(a.hasOwnProperty(0)); // false

console.log("Setting to `undefined`");
var a = ["a", "b", "c", "d", "e"];
console.log(a.length);            // 5
a[0] = undefined;
console.log(a.length);            // still 5
console.log(a[0]);                // undefined
console.log("0" in a);            // true
console.log(a.hasOwnProperty(0)); // true

---

* (que é um post no meu blog pouco anêmica)

Answer 16

Atualmente, existem duas maneiras de fazer isso

1. usando splice ()

   arrayObject.splice(index, 1);

2. usando delete

   delete arrayObject[index];

Mas eu sempre sugerir a utilização de emenda para objetos de matriz e apagar para atributos de objeto porque DELETE não atualização comprimento da matriz.

Answer 17

A diferença pode ser visto, registando o comprimento de cada matriz após o operador delete e método splice() são aplicados. Por exemplo:

operador delete

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
delete trees[3];

console.log(trees); // ["redwood", "bay", "cedar", empty, "maple"]
console.log(trees.length); // 5

O operador delete retira o elemento da matriz, mas o "marcador" do elemento ainda existe. oak foi removido, mas ele ainda tem espaço na matriz. Devido a isso, o comprimento da matriz permanece 5.

método splice ()

var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
trees.splice(3,1);

console.log(trees); // ["redwood", "bay", "cedar", "maple"]
console.log(trees.length); // 4

O método splice() remove completamente o valor-alvo e o "espaço reservado" também. oak foi removida, bem como o espaço que ocupava na matriz. O comprimento da matriz é agora 4.

Answer 18

OK, imaginar que temos essa matriz abaixo:

const arr = [1, 2, 3, 4, 5];

Vamos fazer de exclusão primeiro:

delete arr[1];

e este é o resultado:

[1, empty, 3, 4, 5];

esvaziar e vamos obtê-lo:

arr[1]; //undefined

Assim meios apenas o valor apagados e é indefinido agora, para comprimento é o mesmo, também ele retornará true ...

Vamos redefinir a nossa gama e fazê-lo com emenda neste momento:

arr.splice(1, 1);

e este é o resultado desta vez:

[1, 3, 4, 5];

Como você vê o comprimento da matriz alterados e arr[1] é 3 agora ...

Além disso, este retornará o item excluído em uma matriz que é [3] neste caso ...

Answer 19

A maneira mais fácil é provavelmente

var myArray = ['a', 'b', 'c', 'd'];
delete myArray[1]; // ['a', undefined, 'c', 'd']. Then use lodash compact method to remove false, null, 0, "", undefined and NaN
myArray = _.compact(myArray); ['a', 'c', 'd'];

Espero que isso ajude. Referência: https://lodash.com/docs#compact

Answer 20

Para quem quer usar Lodash pode usar: myArray = _.without(myArray, itemToRemove)

Ou, como eu uso no Angular2

import { without } from 'lodash';
...
myArray = without(myArray, itemToRemove);
...

Answer 21

Excluir : delete irá eliminar a propriedade do objeto, mas não vai reindex a matriz ou actualização do seu comprimento. Isso faz com que ele aparece como se fosse indefinida:

splicing : efectivamente remove o elemento, reindexa a matriz, e as alterações seu comprimento.

elemento Excluir última

arrName.pop();

elemento Excluir primeira

arrName.shift();

Excluir do meio

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

Ex: arrName.splice(1,1);

elemento um Excluir última

arrName.splice(-1);

Apagar usando o número de índice de matriz

 delete arrName[1];

Answer 22

Se o elemento desejado para excluir está no meio (dizer que deseja excluir 'c', que o seu índice é 1), você pode usar:

var arr = ['a','b','c'];
var indexToDelete = 1;
var newArray = arr.slice(0,indexToDelete).combine(arr.slice(indexToDelete+1, arr.length))

Answer 23

IndexOf aceita também um tipo de referência. Suponha que o cenário a seguir:

var arr = [{item: 1}, {item: 2}, {item: 3}];
var found = find(2, 3); //pseudo code: will return [{item: 2}, {item:3}]
var l = found.length;

while(l--) {
   var index = arr.indexOf(found[l])
      arr.splice(index, 1);
   }
   
console.log(arr.length); //1

Ao contrário:

var item2 = findUnique(2); //will return {item: 2}
var l = arr.length;
var found = false;
  while(!found && l--) {
  found = arr[l] === item2;
}

console.log(l, arr[l]);// l is index, arr[l] is the item you look for

Answer 24

function deleteFromArray(array, indexToDelete){
  var remain = new Array();
  for(var i in array){
    if(array[i] == indexToDelete){
      continue;
    }
    remain.push(array[i]);
  }
  return remain;
}

myArray = ['a', 'b', 'c', 'd'];
deleteFromArray(myArray , 0);

// resultado: meuArray = [ 'b', 'c', 'd'];