Eliminazione di elementi dell'array in JavaScript: elimina vs unisci

StackOverflow https://stackoverflow.com/questions/500606

Domanda

Qual è la differenza tra l'utilizzo IL delete operatore sull'elemento dell'array invece di using IL Array.splice metodo?

Per esempio:

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

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

Perché utilizzare anche il metodo di giunzione se posso eliminare elementi dell'array come posso fare con gli oggetti?

È stato utile?

Soluzione

delete eliminerà la proprietà dell'oggetto, ma non reindex la matrice o aggiornare la sua lunghezza. Questo lo rende sembra come se non è definito: 

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

Si noti che non è effettivamente fissato al undefined valore, piuttosto la struttura viene rimosso dalla matrice, rendendo appare indefinito. Gli strumenti di sviluppo Chrome rendono questa chiara distinzione stampando empty quando si accede la matrice. 

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

myArray.splice(start, deleteCount) in realtà rimuove l'elemento, indicizzando l'array, e cambia la sua lunghezza. 

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

Altri suggerimenti

Array.remove () Metodo

John Resig , creatore di jQuery ha creato un metodo Array.remove molto utile che io uso sempre nei miei progetti. 

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

ed ecco alcuni esempi di come potrebbe essere utilizzato: 

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

sito di John

A causa cancellare rimuove solo l'oggetto dalla elemento della matrice, la lunghezza dell'array non cambierà. Splice rimuove l'oggetto e riduce l'array.

Il seguente codice visualizzerà "a", "b", "indefinito", "d" 

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

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

considerando che questo mostrerà "a", "b", "d" 

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

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

mi sono imbattuto su questa domanda durante il tentativo di capire come rimuovere ogni occorrenza di un elemento da un array. Ecco un confronto di splice e delete per la rimozione di tutti i 'c' dal Array 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"]
​

Nucleo JavaScript 1.5 Riferimento> Operatori> Operatori speciali> delete operatore :

  

Quando si elimina un elemento di un array, il   lunghezza della matrice non è influenzato. Per   ad esempio, se si elimina un [3], un [4] è   ancora [4] e [3] è indefinito. Questo   vale anche se si elimina l'ultimo   elemento dell'array (cancella   un [a.length-1]).

splice possa funzionare con indici numerici.

mentre delete può essere usato contro altri tipi di indici ..

Esempio: 

delete myArray['text1'];

E 'probabilmente anche opportuno ricordare che giunzione funziona solo su array. (Proprietà degli oggetti non possono essere invocate per seguire un ordine coerente.)

Per rimuovere il coppia chiave-valore da un oggetto, eliminare è in realtà ciò che si vuole: 

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

Come affermato molte volte sopra, utilizzando splice() sembra una soluzione perfetta. Documentazione su Mozilla:

IL splice() Il metodo modifica il contenuto di un array rimuovendo elementi esistenti e/o aggiungendo nuovi elementi.

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

Sintassi

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

Parametri

inizio

Indice da cui iniziare a modificare l'array.Se maggiore della lunghezza dell'array, l'indice iniziale effettivo verrà impostato sulla lunghezza dell'array.Se negativo, inizieranno tanti elementi dalla fine.

deleteCount

Un numero intero che indica il numero di vecchi elementi dell'array da rimuovere.Se deleteCount è 0, nessun elemento viene rimosso.In questo caso, dovresti specificare almeno un nuovo elemento.Se deleteCount è maggiore del numero di elementi rimasti nell'array a partire da start, tutti gli elementi fino alla fine dell'array verranno eliminati.

Se deleteCount viene omesso, deleteCount sarà uguale a (arr.length - start).

elemento1, elemento2, ...

Gli elementi da aggiungere all'array, a partire dall'indice iniziale.Se non specifichi alcun elemento, splice() rimuoverà solo gli elementi dall'array.

Valore di ritorno

Un array contenente gli elementi eliminati.Se viene rimosso un solo elemento, viene restituito un array di un elemento.Se non viene rimosso alcun elemento, viene restituito un array vuoto.

[...]

Elimina Vs giuntura

quando si elimina un elemento da un array 

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

quando unisci 

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

in caso di elimina elemento viene eliminato ma indice rimane vuoto

mentre nel caso di giuntura elemento viene eliminato e il indice elementi d'appoggio si riduce di conseguenza

Elimina si comporta come una situazione non del mondo reale, è solo rimuove la voce, ma la lunghezza dell'array rimane lo stesso:

esempio dal terminale nodo: 

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

Ecco una funzione per rimuovere un elemento di un array per indice, utilizzando slice () , ci vuole l'arr come il primo arg, e l'indice del membro che si desidera eliminare la secondo argomento. Come si può vedere, si cancella in realtà il membro della matrice, e ridurrà la lunghezza dell'array da 1 

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

Ciò che la funzione di cui sopra non è prendere tutti i membri fino all'indice, e tutti i membri dopo l'indice, e li concatena insieme, e restituisce il risultato.

Ecco un esempio utilizzando la funzione di cui sopra come modulo nodo, visto il terminale sarà utile: 

> 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

Si prega di notare che questo non funzionerà uno array con gonzi in essa, perché indexOf ( "c") sarà solo ottenere la prima occorrenza, e solo unire e rimuovere la prima "c" che trova.

Se si desidera iterare un array di grandi dimensioni ed eliminare selettivamente gli elementi, sarebbe costoso chiamare splice() per ogni eliminazione poiché splice() dovrebbe reindicizzare ogni volta gli elementi successivi.Poiché gli array sono associativi in ​​Javascript, sarebbe più efficiente eliminare i singoli elementi e successivamente reindicizzare l'array.

Puoi farlo costruendo un nuovo array.per esempio

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

Ma non penso che tu possa modificare i valori chiave nell'array originale, il che sarebbe più efficiente: sembra che potresti dover creare un nuovo array.

Tieni presente che non è necessario verificare le voci "non definite" poiché in realtà non esistono e il ciclo for non le restituisce.È un artefatto della stampa dell'array che li visualizza come indefiniti.Non sembrano esistere nella memoria.

Sarebbe bello se potessi usare qualcosa come slice() che sarebbe più veloce, ma non reindicizza.Qualcuno conosce un modo migliore?

In realtà, probabilmente puoi farlo sul posto come segue, che è probabilmente più efficiente, dal punto di vista delle prestazioni:

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)
},

si può usare qualcosa di simile 

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]

Perché non basta filtrare? Penso che sia il modo più chiaro per prendere in considerazione le matrici in js. 

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

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

Esempio: 

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

banana è cancellato e la durata della serie = 2

Sono cose diverse che hanno scopi diversi.

splice è specifico dell'array e, se utilizzato per l'eliminazione, rimuove le voci dall'array E sposta tutte le voci precedenti verso l'alto per colmare il vuoto.(Può essere utilizzato anche per inserire voci o entrambe contemporaneamente.) splice cambierà il length dell'array (assumendo che non sia una chiamata no-op: theArray.splice(x, 0)).

delete non è specifico dell'array;è progettato per l'uso su oggetti:Rimuove una proprietà (coppia chiave/valore) dall'oggetto su cui la usi.Si applica solo agli array perché sono array standard (ad esempio, non tipizzati) in JavaScript non sono affatto array*, sono oggetti con una gestione speciale per determinate proprietà, come quelli i cui nomi sono "indici di array" (che sono definito come nomi di stringa "...il cui valore numerico i è nell'intervallo +0 ≤ i < 2^32-1") E length.Quando usi delete per rimuovere una voce dell'array, tutto ciò che fa è rimuovere la voce;non sposta le altre voci che lo seguono per colmare il vuoto, quindi l'array diventa "sparso" (alcune voci mancano completamente).Non ha alcun effetto su length.

Un paio delle risposte attuali a questa domanda affermano erroneamente che using delete "imposta la voce su undefined".Non è corretto.Esso rimuove la voce (proprietà) interamente, lasciando uno spazio vuoto.

Usiamo del codice per illustrare le differenze:

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

* (questo è un post sul mio piccolo blog anemico)

Al momento ci sono due modi per fare questo

  1. utilizzando splice ()

    arrayObject.splice(index, 1);

  2. utilizzando eliminare

    delete arrayObject[index];

Ma io consiglio sempre di usare giunzione per gli oggetti Array e cancellare per gli attributi degli oggetti, perché eliminare non aggiorna lunghezza dell'array.

La differenza può essere vista registrando la lunghezza di ciascun array dopo il file delete operatore e splice() metodo vengono applicati.Per esempio:

operatore cancella

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

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

IL delete L'operatore rimuove l'elemento dall'array, ma il "segnaposto" dell'elemento esiste ancora. oak è stato rimosso ma occupa ancora spazio nell'array.Per questo motivo, la lunghezza dell'array rimane 5.

metodo splice()

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

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

IL splice() Il metodo rimuove completamente il valore di destinazione E anche il "segnaposto". oak è stato rimosso così come lo spazio che occupava nell'array.La lunghezza dell'array è ora 4.

OK, immagina di avere questo array qui sotto:

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

Prima eliminiamo:

delete arr[1];

e questo è il risultato:

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

vuoto! e prendiamolo:

arr[1]; //undefined

Quindi significa solo il valore cancellato e così è non definito ora, quindi la lunghezza è la stessa, verrà restituita VERO...

Ripristiniamo il nostro array e questa volta lo facciamo con splice:

arr.splice(1, 1);

e questo è il risultato questa volta:

[1, 3, 4, 5];

Come vedi, la lunghezza dell'array è cambiata e arr[1] È 3 Ora...

Anche questo restituirà l'elemento eliminato in un Array che è [3] in questo caso...

Il modo più semplice è probabilmente 

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

Spero che questo aiuti. Riferimento: https://lodash.com/docs#compact

Per chi vuole usare Lodash possono utilizzare: myArray = _.without(myArray, itemToRemove)

O come io uso in Angular2 

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

Elimina : Elimina consente di eliminare la proprietà dell'oggetto, ma non sarà reindex   la matrice o modificare la sua lunghezza. Questo lo rende sembra come se fosse   non definito:

     

giuntura : in realtà rimuove l'elemento, indicizzando dell'array e modifiche   la sua lunghezza.

Elimina elemento da ultimo 

arrName.pop();

Elimina elemento dal primo 

arrName.shift();

Elimina dal mezzo 

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

Ex: arrName.splice(1,1);

Elimina un elemento da ultimo 

arrName.splice(-1);

Elimina utilizzando numero di indice array 

 delete arrName[1];

Se l'elemento desiderato da eliminare è nel mezzo (diciamo che vogliamo eliminare 'c', che il suo indice è 1), è possibile utilizzare: 

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

IndexOf accetta anche un tipo di riferimento. Supponiamo che il seguente scenario: 

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

A differenza: 

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

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

// risultato: myArray = [ 'b', 'c', 'd'];

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top