come rimuovere un particolare elemento da un array in JavaScript?

ho una serie di Numeri, e sto usando il metodo .push() per aggiungere elementi ad esso.

esiste un modo semplice per rimuovere un elemento specifico da un array? l'equivalente di qualcosa come array.remove(number);.

devo usare core JavaScript - non sono ammessi quadri.


En title : How do I remove a particular element from an array in JavaScript?

228 Comments:

  1. 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)

    1. non sono un grande fan di questo approccio. se si finisce per utilizzare diverse librerie o strutture, possono finire in conflitto tra loro.
    1. questo ha funzionato, ho scelto di andare con la funzione indexOf alla fine però. grazie per l'aiuto!
    1. cattiva idea, vedere questo post: http://stackoverflow.com/questions/948358/array-prototype-problem
    1. utilizzare Object.defineProperty https://stackoverflow.com/a/35518127/3779853 e si è bene andare.
  2. non so come si aspetta array.remove(int) a comportarsi. ci sono tre possibilità che posso pensare che si potrebbe desiderare.

    per rimuovere un elemento di un array con un indice i:

    array.splice(i, 1);
    

    se si desidera rimuovere ogni elemento con valore number dalla matrice:

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

    se si vuole solo fare l'elemento all'indice i non esiste più, ma non si desidera che gli indici degli altri elementi per cambiare:

    delete array[i];
    
    1. @FelixKling dipende, funziona se si vuole fare in modo che array.hasOwnProperty(i) restituisce false e hanno l'elemento in quella posizione ritorno undefined. ma ammetto che non è una cosa molto comune da voler fare.
    1. delete non aggiorna la lunghezza dell'array né cancella realmente l'elemento, lo sostituisce solo con il valore speciale undefined.
    1. @diosney Non so cosa si intende quando si dice che in realtà non cancella l'elemento. inoltre, lo fa più che semplicemente sostituendo il valore a quell'indice con undefined: rimuove sia l'indice che il valore dall'array, cioè dopo delete array[0], "0" in array restituisce false.
    1. per (var i = array.length-1; i > =; i--) dovrebbe essere per (var i = array.length-1; i > =; i--) perché l'indicizzazione inizia da (non c'è elemento in array [array.length])
    1. delete è un buon meccanismo se si tratta di proprietà con nome var array=[];array['red']=1;array['green']=2;array['blue']=3;delete array['green'];
    1. @Kavius Non essere troppo imbarazzato. una volta ho letto un libro pubblicato su JS che ha descritto "array associativi" in JavaScript esattamente come il tuo commento li ha descritti. e 'un errore facile da fare se si sta avvicinando JavaScript da un'altra lingua.
    1. @BenG il tuo link non indirizza affatto gli array (credo? e 'una pagina enorme, ho appena guardato la sezione che hai collegato) si parla solo di vanificare riferimenti a namespaces. elementi Nulling in un array sarà ancora mantenere vivo il riferimento (raccolta dei rifiuti era meglio mai venuto per i miei valori array vuoti)...
    1. indicizzati per loop non funzionerebbero per tutti gli array. se avete usato precedentemente delete sull'array, allora for loop andrà in crash.
    1. Downvotato, perché alcune persone sfogliano la risposta, vedere l'operazione delete, e solo ciecamente copiare nel loro codice, perché sembra di destra a loro. non va bene! Downvotato.
    1. @GrantGryczan Questa parte della risposta è in fondo. non è colpa mia se la gente salta in fondo e ignora la descrizione che descrive quello che fa.
    1. non si dà nemmeno un avvertimento (figuriamoci in grassetto), che non è così che si rimuove le cose dagli array. l'esistenza di quella linea di codice in questa risposta non è utile. qui, mi permetta di fare una modifica. vorrei solo raccomandare completamente rimuoverlo però. non aggiunge nulla di pratico.
    1. mi dispiace, non sono d'accordo. non vedo la necessità che questo venga rimosso. il testo di cui sopra spiega chiaramente cosa fa, e aiuta le persone che non sanno cosa delete fa per capire perché non funziona come si aspettano.
    1. ci sono modi molto migliori per farlo, eliminare è una cattiva pratica su un array
  3. trovare il index dell'elemento dell'array che si desidera rimuovere, quindi rimuovere tale indice con splice.

    The splice() method changes the contents of an array by removing existing elements and/or adding new elements.

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

    il secondo parametro di splice è il numero di elementi da rimuovere. si noti che splice modifica l'array e restituisce un nuovo array contenente gli elementi rimossi.

    1. @Peter, sì potrebbe essere giusto. questo articolo spiega di più e ha una soluzione per i browser incompatibili: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/indexOf
    1. è possibile facilitare l'uso di questo aggiungendo una funzione delete sul prototipo array. ho preso uso del vostro esempio in un gist che elimina tutti gli elementi mirati nell'array invece di solo 1.
    1. e 'troppo tardi per modificare il mio ultimo commento, ma voglio solo correggere me stesso. chiamare delete su un array non è andare in IE 8. ho aggiornato il gist per utilizzare destroy invece.
    1. pericoloso! pericoloso! se si lavora con valori dinamici (aggiungere e rimuovere valori dinamici da array) e il valore non esiste in array (l'indice diventa -1) il codice precedente rimuoverà l'ultimo elemento dell'array.
    1. @AlexandreWiechersVaz Naturalmente conserva ordine, se non lo ha poi sarebbe assolutamente inutile
    1. indexOf mantenuto tornando -1 nella mia versione di Firefox (30.0). ho finito per scrivere solo un semplice ciclo per trovare l'indice e funziona bene...
    1. domanda correlata: come farlo con jQuery (jQuery.grep). http://stackoverflow.com/questions/3596089/how-to-remove-specifc-value-from-array-using-jquery
    1. @UpTheCreek Ho pensato che è chiaro: avere un array riempito dinamicamente significa a volte si dispone di un array vuoto. utilizzando questa soluzione si può provare a rimuovere l'ultimo elemento che non esiste. il risultato è un errore JS. se avete lo stesso numero di elementi in questo array allora tutto è buono. è possibile utilizzarlo.
    1. @AdrianP. array.indexOf(testValue) su array vuoto sarà -1, e se si sta testando per questo allora nessuna scheggia. forse la risposta è cambiata da allora.
    1. e notare che se si sta lavorando con tipi non primitivi, Array.indexOf() non prova per l'uguaglianza degli oggetti. funziona solo se si passa esattamente lo stesso riferimento oggetto. vedere: http://jsfiddle.net/b0e7zsm3/
    1. questo non è un buon metodo da usare quando si iterano gli array. quello che succede nel mio caso è che non è l'elemento in questione che viene rimosso, ma quello dopo. inoltre, ho usato questo con jQuery .Each funzione e provoca problemi come l'array diventa più piccolo, ma è Lunghezza è ancora iterata (il che significa che cercherà di accedere a valori vuoti alla fine). non ho potuto riprodurre l'ultimo errore, ma il primo che posso mostrare in questo JSBin (https://jsbin.com/xufovopoji/edit?html,js,output)
    1. non usare questo metodo con un ciclo for, invece usare while(myarry.lenth--). il motivo è "l'array viene ri-indicizzato quando si fa un .splice (), il che significa che si salta sopra un indice quando uno viene rimosso, e la cache .length è obsoleto." http://stackoverflow.com/a/9882349/922522
    1. IE 7, IE8, IE9, IE10 ar non supportato da Microsoft stessa, perché gli sviluppatori web dovrebbero sostenere quei vecchi browser? basta mostrare la notifica di aggiornamento del browser! https://support.microsoft.com/en-us/lifecycle/search?sort=PN&alpha=internet%20explorer&Filter=FilterNO
    1. @Creator che lascia un indefinito nell'array. https://jsfiddle.net/dsup87xL/
    1. @LukasLiesis Questo non è mai e non è mai stata una scelta di sviluppatori. quando ci si rivolge a un pubblico specifico come le organizzazioni pubbliche che non possono aggiornare per ragioni interne o non Stati Uniti / UE paesi (che hanno ancora un sacco di utenti su WinXP), dovrete fornire il supporto per IE8 per quegli utenti. dipende solo di chi il tuo sito web è per, non si può avere un approccio generico su questa questione.
    1. qualcuno può spiegare come funziona realmente il polifill? il codice sembra molto interessante. stai confrontando infinito (osservando tipo variabile) a Math.abs(a) && (a = 0) e fare qualche altra roba incredibile che coinvolge >>>?
    1. per ottenere l'indice di un oggetto in un array dalla sua proprietà, è possibile utilizzare TheArray.map(function(e) {return e.property;}).indexOf(PROPERTY_VALUE_TO_SEARCH) (IE 9 +), o TheArray.map(e => e.property).indexOf(PROPERTY_VALUE_TO_SEARCH) se il browser supporta i Functons Arrow.
    1. Arr = [1,2,3,4,5] var filtered = arr.filter (function (ele) {return ele! = 3;}); / / filtrato = [1,2,4,5];
    1. le specifiche OPS fornite non specificano una serie di interi unici. indexOf restituisce solo la posizione della prima corrispondenza trovata (da opzionale "fromIndex").
    1. non sicuro se vale una nota, ma essere consapevoli per il comportamento in caso di elementi duplicati. solo il primo viene rimosso in questo approccio.
    1. non sposterà l'indice dell'allineamento al livello più basso e l'elemento successivo non sarà disponibile nella lista se stiamo looping attraverso un allineamento.
    1. splice è il migliore, con delete il mio JSON.stringify ha un nulla sul posto che ha cancellato
    1. @TomWadley perché la prima condizione è (indice > -1) invece di (indice! = -1)?
    1. @MrClan dalla documentazione, sembra che indexOf() non restituirà mai un numero negativo diverso da -1 in modo che != -1 o !== -1 sarebbe perfettamente bene. nessun motivo particolare per utilizzare > -1.
    1. Splice può essere meglio utilizzato quando si conosce l'indice e tutti i valori desiderati da eliminare, sono in una sequenza. se non si conosce l'indice, qui ci sono alcuni buoni alterna utilizzando scheggia, filtro, shift, pop- https://stackoverflow.com/a/54390552/8958729
  4. dipende se si desidera mantenere un punto vuoto o meno.

    se si desidera uno slot vuoto, eliminare va bene:

    delete array[ index ];
    

    se non lo fai, dovresti usare il metodo Splice:

    array.splice( index, 1 );
    

    e se avete bisogno del valore di tale elemento, si può solo memorizzare l'elemento dell'array restituito:

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

    nel caso in cui si desidera farlo in qualche ordine, è possibile utilizzare array.pop() per l'ultimo o array.shift() per il primo (ed entrambi restituire il valore della voce troppo).

    e se non si conosce l'indice della voce, è possibile utilizzare array.indexOf( item ) per ottenerlo (in un if() per ottenere un elemento o in un while() per ottenere tutti loro). array.indexOf( item ) restituisce sia l'indice o -1 se non trovato.

    1. vale la pena notare che var value non memorizza il valore rimosso, ma un array contenente il valore rimosso.
    1. se si desidera "svuotare uno slot", utilizzare array[index] = undefined;. l'utilizzo di delete distrugge l'ottimizzazione.
    1. @Jakub commento molto buono perché per capire che ho perso molto tempo e pensato che il mio codice di applicazione è in qualche modo rotto...
    1. ultimo paragrafo con la spiegazione di ciò che si ottiene da indexOf è stato davvero utile
  5. se si desidera un nuovo array con le posizioni eliminate, è sempre possibile eliminare l'elemento specifico e filtrare l'array. potrebbe essere necessario un'estensione dell'oggetto array per i browser che non implementare il metodo di filtro, ma a lungo termine è più facile in quanto tutto quello che fate è questo:

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

    dovrebbe visualizzare [1, 2, 3, 4, 6]

  6. ci sono due approcci principali:

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

    2. cancella: delete anArray[index];

    fare attenzione quando si utilizza delete per un array. è buono per eliminare gli attributi degli oggetti ma non così buono per gli array. è meglio usare splice per gli array.

    tenete a mente che quando si utilizza delete per un array si potrebbe ottenere risultati sbagliati per anArray.length. in altre parole, delete rimuoverebbe l'elemento, ma non aggiornerebbe il valore della proprietà length.

    si può anche aspettare di avere buchi nei numeri indice dopo l'utilizzo di eliminare, ad esempio si potrebbe finire con avere indici fabri4,8,9,11 e lunghezza come era prima di utilizzare eliminare. in questo caso, tutti i loop indicizzati for andranno in crash, dato che gli indici non sono più sequenziali.

    se si è costretti ad usare delete per qualche ragione, allora si dovrebbe usare for each loop quando si ha bisogno di loop attraverso array. di fatto, evitate sempre di usare, se possibile, dei cicli per indicizzati. in questo modo il codice sarebbe più robusto e meno incline a problemi con gli indici.

  7. aggiornamento: questo metodo è consigliato solo se non è possibile utilizzare ECMAScript 2015 (precedentemente noto come ES6). se è possibile utilizzarlo, altre risposte qui forniscono implementazioni molto più neater.


    questo gist qui risolve il tuo problema, e cancella anche tutte le occorrenze dell'argomento invece di solo 1 (o un valore specificato).

    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: 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]
    
  8. controlla questo codice. funziona in ogni browser principale.

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

    chiama questa funzione

    remove_item(array,value);
    
    1. @RolandIllig Tranne l'uso di un for in -loop e il fatto che lo script potrebbe fermarsi prima, restituendo direttamente il risultato dal ciclo.
      i voti favorevoli sono ragionevoli;)
    1. questo è un approccio eccellente per i piccoli array. questo lavora in ogni navigatore, usa il codice minimo e intuitivo, e senza qualsiasi quadro complesso supplementare, gli spessori, o i poliriempimenti.
    1. dovrei anche ribadire il commento di yckart che for( i = 0; i < arr.length; i++ ) sarebbe un approccio migliore in quanto conserva gli indici esatti contro qualsiasi ordine il browser decide di memorizzare le voci (con for in). così facendo si ottiene anche l'indice di matrice di un valore, se ne avete bisogno.
  9. è possibile iterare su ogni array -item e splice se esiste nel vostro array.

    function destroy(arr, val) {
        for (var i = 0; i < arr.length; i++) if (arr[i] === val) arr.splice(i, 1);
        return arr;
    }
    
    1. [1,2,3,3,4,5], 3) restituisce [1,2,3,4,5]. non dovrei essere incrementato quando l'array viene splicato.
    1. @RenzedeWaal questo potrebbe funzionare se si iterava sopra i indietro invece di inoltrare però. per (var i = arr.length; i-- > 0;) & # 91; editare] già pubblicato qui
  10. crea un nuovo array:

    var my_array = new Array();
    

    aggiungere elementi a questo array:

    my_array.push("element1");
    

    l'indice di funzione di (indice di resa o -1 quando non trovato):

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

    controllare l'indice di questo elemento (testato con firefox e IE8 +):

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

    rimuovere 1 elemento situato all'indice dall'array

    my_array.splice(index, 1);
    
  11. un amico stava avendo problemi in Internet & nbsp; Explorer & nbsp; 8, e mi ha mostrato quello che ha fatto. gli ho detto che era sbagliato, e mi ha detto che ha ottenuto la risposta qui. la risposta attuale non funziona in tutti i browser (Internet & nbsp; Explorer & nbsp; 8 per esempio), e sarà solo rimuovere la prima occorrenza della voce.

    rimuovere TUTTE le istanze da un array

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

    esso scorre all'indietro attraverso l'array (dato che gli indici e la lunghezza cambieranno man mano che gli elementi verranno rimossi) e rimuove l'elemento se viene trovato. funziona in tutti i browser.

    1. @sroes non dovrebbe essere perché il ciclo inizia a i = arr.length -1 o i-- rendendo lo stesso come l'indice max. arr.length è solo un valore iniziale per i. i-- sarà sempre veritiero (e riducendo di 1 ad ogni ciclo op) fino a quando non sarà uguale 0 (un valore falso) e il ciclo si fermerà.
    1. la seconda funzione è piuttosto inefficiente. su ogni iterazione "indexOf" inizierà la ricerca dall'inizio della matrice.
    1. @AmberdeBlack, hai esattamente ragione. sorpreso non ho capito che quando ho risposto: http://jsperf.com/remove-all-from-array
    1. @AmberdeBlack, si era preoccupati di chiamare indexOf ripetutamente, che in realtà non è nemmeno vicino ad essere così male come chiamare scheggia su ogni iterazione.
    1. @AmberdeBlack, su una collezione con più di 1 occorrenza di elemento, è molto meglio chiamare il metodo del filtro invece arr.filter(function (el) { return el !== item }), evitando la necessità di mutare l'array più volte. ciò consuma un po'più memoria, ma funziona molto più efficientemente, poiché ci è meno lavoro che deve essere fatto.
    1. @AlJey, è disponibile solo da IE9 +. c'è ancora una possibilità che non funzionerebbe.
    1. @AmberdeBlack, che non è un argomento valido in tutti questi giorni, basta fare ciò che la funzione di filtro fa o, meglio ancora, semplicemente includere es5-shim.js nella vostra applicazione.
    1. questa risposta ha funzionato per me perché avevo bisogno di diversi elementi rimossi, ma non in un ordine particolare. la progressione all'indietro del ciclo for qui gestisce la rimozione di elementi dall'array perfettamente.
  12. è possibile fare un ciclo indietro per assicurarsi di non avvitare gli indici, se ci sono più istanze dell'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);
    }
    

    demo dal vivo

  13. John Resig ha pubblicato una buona implementazione:

    // 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 non si desidera estendere un oggetto globale, si può fare qualcosa come il seguente, invece:

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

    ma il motivo principale che sto postando questo è quello di mettere in guardia gli utenti contro l'implementazione alternativa suggerita nei commenti a quella pagina (Dicembre 14, 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;
    };
    

    sembra funzionare bene in un primo momento, ma attraverso un processo doloroso ho scoperto che non riesce quando si cerca di rimuovere il secondo ultimo elemento in un array. ad esempio, se si dispone di un array di 10 elementi e si tenta di rimuovere il nono elemento con questo:

    myArray.remove(8);
    

    si finisce con un array di 8 elementi. non so perché, ma ho confermato l'implementazione originale di John non ha questo problema.

    1. appena appreso dal modo difficile perché è una buona idea utilizzare Object.prototype.hasOwnProperty sempre ¬ ¬
  14. non è necessario utilizzare indexOf o splice. tuttavia, funziona meglio se si desidera rimuovere solo una occorrenza di un elemento.

    trovare e spostare (spostare):

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

    utilizzare indexOf e splice (indexOf):

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

    usare solo splice (spline):

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

    tempi di esecuzione su nodejs per array con 1000 elementi (media su 10000 run):

    indexOf è circa 10x più lento della mossa. anche se migliorato rimuovendo la chiamata a indexOf in scheggia si comporta molto peggio di spostare.

    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
    
    1. sembra che il metodo 'mossa' presentato qui dovrebbe funzionare in tutti i browser, ed evita anche la creazione di un array aggiuntivo; la maggior parte delle altre soluzioni qui hanno uno o entrambi questi problemi. penso che questo merita molto più voti, anche se non sembra "abbastanza".
  15.   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');
    
  16. ho anche corso nella situazione in cui ho dovuto rimuovere un elemento da Array. .indexOf non funzionava in IE* in modo da condividere il mio lavoro jQuery.inArray() soluzione.

    var index = jQuery.inArray(val,arr);
    if (index > -1) {
        arr.splice(index, 1);
        //console.log(arr);
    }
    
    1. jQuery è sempre un bene per prendersi cura di eventuali problemi di compatibilità cross-browser delle diverse API JavaScript.
  17. messaggio modificato il 2016 ottobre

    • semplice, intuitivo ed esplicito ({5})
    • farlo immutabile (array originale rimanere invariato)
    • farlo con le funzioni standard JS, se il tuo browser non le supporta - usa polyfill

    in questo esempio di codice uso la funzione "array.filter (...)" per rimuovere gli elementi indesiderati dall'array, questa funzione non modifica l'array originale e ne crea uno nuovo. se il tuo browser non supporta questa funzione (ad esempio IE prima della versione 9, o Firefox prima della versione 1.5), considerare l'utilizzo del filtro polyfill da Mozilla.

    rimozione elemento (ECMA-262 Edition 5 codice alias 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 ]
    

    rimozione articolo (codice 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 ]
    

    importante ES2015 "() = > {}" sintassi funzione freccia non è supportato in IE a tutti, Chrome prima 45 versione, Firefox prima 22 versione, Safari prima 10 versione. per utilizzare la sintassi ES2015 nei vecchi browser è possibile utilizzare BabelJS


    rimozione di più elementi (codice ES2016)

    un ulteriore vantaggio di questo metodo è che è possibile rimuovere più elementi

    let forDeletion = [2, 3, 5]
    
    let arr = [1, 2, 3, 4, 5, 3]
    
    arr = arr.filter(item => !forDeletion.includes(item))
    // !!! Read below about array.includes(...) support !!!
    
    console.log(arr)
    // [ 1, 4 ]
    

    importante "array.includes (...)" funzione non è supportato in IE a tutti, Chrome prima 47 versione, Firefox prima 43 versione, Safari prima 9 versione e Edge prima 14 versione quindi ecco polyfill da Mozilla

    rimozione di più elementi (all'avanguardia sperimentale JavaScript 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 ]
    

    prova da solo in BabelJS:)

    riferimento di riferimento riferimento

    1. ma, a volte vogliamo rimuovere elementi da array originale (non immutabile), per esempio array utilizzato in direttiva angolare 2 * ngFor
    1. meglio della soluzione accettata perché non assume una sola occorrenza di una corrispondenza e l immutabilità è preferibile
    1. qual è il punto di immutabilità menzionato se avete usato l'assegnazione della stessa variabile nei vostri esempi? :):)
    1. @mench perché sarebbe un esempio troppo complesso se usassi sia l'immutabilità dei riferimenti che l'immutabilità dei dati. allora dovrei usare un certo genere di contenitore della condizione. anche l immutabilità dei dati è sufficiente per evitare la maggior parte degli errori collaterali.
    1. questa non è una buona risposta, perché crea un nuovo array, creando così un nuovo riferimento. non rimuove i suoi elementi. crea una nuova Array e la assegna. così, per esempio, avere let arr = arr2 = [1,3,2]; e fare quel filtro arr = arr.filter(el => el !==3) non comporta alcuna modifica su arr2, mentre si fa il frammento, entrambi gli array saranno modificati.
    1. @Nathan in confronto a quale metodo e quale scenario? più lento significa tempo di esecuzione?
    1. @Ujeenator filtro è super lento se è necessario rimuovere un singolo elemento da un array
    1. questo non funziona se si vuole solo rimuovere una occorrenza di un valore da un array.

      ad es. per esempio [1,2,3,3,4,5].filter(num => num == 3) rimuoverà entrambi i valori di 3

    1. questa è una grande risposta. Splice è una funzione specializzata per la mutazione non il filtraggio. filter può avere prestazioni più lente, ma è codice più sicuro e migliore. inoltre, è possibile filtrare indicizzando un secondo argomento nel lambda: arr.filter((x,i)=>i!==2)
    1. essere prudenti usando il filtro e l'assegnazione quando l'allineamento è fatto riferimento da molti.
  18. sono abbastanza nuovo di JavaScript e aveva bisogno di questa funzionalità. ho scritto semplicemente questo:

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

    poi quando voglio usarlo:

    //Set-up some dummy data
    var dummyObj = {name:"meow"};
    var dummyArray = [dummyObj, "item1", "item1", "item2"];
    
    //Remove the dummy data
    removeFromArray(dummyArray, dummyObj);
    removeFromArray(dummyArray, "item2");
    

    uscita - Come previsto. ["Item1", "Item1"]

    si possono avere esigenze diverse da me, in modo da poter facilmente modificare per soddisfare loro. spero che questo aiuti qualcuno.

    1. questo avrà un comportamento terribile se il vostro array è davvero lungo e ci sono diversi casi di elemento in esso. il metodo indexOf dell'allineamento comincerà all'inizio ogni volta, in modo da il vostro costo sta andando essere O (n ^ 2).
  19. sulla base di tutte le risposte che erano principalmente corrette e tenendo conto delle best practice suggerite (soprattutto non usando direttamente Array.prototipo), ho elaborato il seguente codice:

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

    esaminando la funzione di cui sopra, nonostante il fatto che funziona bene, ho capito che ci potrebbe essere qualche miglioramento delle prestazioni. usare ES6 invece di ES5 è un approccio molto migliore. a tal fine, questo è il codice migliorato:

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

    come utilizzare:

    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)
    

    attualmente sto scrivendo un post sul blog in cui ho analizzato diverse soluzioni per Array senza problemi e rispetto il tempo necessario per eseguire. aggiornerò questa risposta con il link una volta che ho finito quel post. solo per farvi sapere, Ho confrontato il sopra contro di lodash senza e nel caso in cui il browser supporta Map, batte lodash! si noti che non sto usando Array.prototype.indexOf o Array.prototype.includes come avvolgere i exlcudeValues in un Map o Object rende interrogazione più veloce!

  20. so che ci sono già molte risposte, ma molte sembrano complicare il problema. ecco un modo semplice, ricorsivo di rimuovere tutte le istanze di una chiave - chiama sé fino a quando l'indice non viene trovato. sì, funziona solo nei browser con indexOf, ma è semplice e può essere facilmente polipieno.

    funzione stand-alone

    function removeAll(array, key){
        var index = array.indexOf(key);
    
        if(index === -1) return;
    
        array.splice(index, 1);
        removeAll(array,key);
    }
    

    metodo prototipo

    Array.prototype.removeAll = function(key){
        var index = this.indexOf(key);
    
        if(index === -1) return;
    
        this.splice(index, 1);
        this.removeAll(key);
    }
    
    1. solo una nota, 1 avvertimento con questo metodo è il potenziale per overflow stack. a meno che non stiate lavorando con array massivi, non dovreste avere un problema.
  21. si può fare facilmente con il metodo del filtro:

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

    questo rimuove tutti gli elementi dalla matrice e funziona anche più veloce quindi combinazione di slice e indexOf

    1. bella soluzione. ma come si fa notare, ma importante per rendere calvo, non produce lo stesso risultato come slice e indexOf dal momento che rimuoverà tutte le occorrenze di 1
    1. @user3711421 Questo è perché solo slice e indexOf non fa quello che vuole "per rimuovere un elemento specifico". rimuove l'elemento solo una volta, questo rimuovere un elemento specifico non importa quanti di loro avete
  22. mi piace questa versione di spline, rimuovendo un elemento dal suo valore usando $.inArray:

    $(document).ready(function(){
        var arr = ["C#","Ruby","PHP","C","C++"];
        var itemtoRemove = "PHP";
        arr.splice($.inArray(itemtoRemove, arr),1);
    });
    
    1. sì corretto, dovresti sapere quale elemento vuoi rimuovere come negli altri esempi.
    1. qualsiasi altro modo per qualche valore ripetuto max 5 volte quindi creare un nuovo array e rimuovere tale valore dall'array? I HAVE THIS KIND OF ARRAY : [ " info.specificAllergy " , " info.specificAllergy " , " info.specificAllergy " , " info.specificAllergy " , " info.specificAllergy " , " info.existingMedicalCondition " , " info.existingMedicalCondition " , " info.existingMedicalCondition " , " info.existingMedicalCondition " , " info.existingMedicalCondition " ]
  23. troppo vecchio per rispondere, ma può aiutare qualcuno, fornendo un predicato invece di un valore.

    nota: aggiornerà l'array specificato e restituirà le righe interessate

    utilizzo utilizzo utilizzo utilizzo

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

    definizione definizione definizione definizione definizione

    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;
        }
    };
    
    1. non so che avete bisogno del controllo -1 (i > -1). inoltre, penso che queste funzioni agiscono più come filtro che rimuovere. se si passa row.id = = = 5, si tradurrà in un array con solo id 5, quindi sta facendo il contrario di remove. sarebbe bello in ES2015: Var risultato = ArrayHelper.remove (myarray, row = > row.id = = = 5);
    1. @WhatWouldBeCool questa funzione modifica l'array originale, e restituisce l'elemento rimosso invece di copiare il risultato in un nuovo array
  24. Underscore.js può essere utilizzato per risolvere i problemi con più browser. utilizza in-build metodi del browser, se presente. se sono assenti come nel caso di vecchi Internet & nbsp; versioni Explorer utilizza i propri metodi personalizzati.

    un semplice esempio per rimuovere elementi da array (dal sito):

    _.without([1, 2, 1, 0, 3, 1, 4], 0, 1); // => [2, 3, 4]
    
  25. 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;
    

    questa soluzione prenderà una serie di input e cercherà attraverso l'input il valore da rimuovere. questo loop attraverso l'intero array di input e il risultato sarà un secondo array interi che ha rimosso l'indice specifico. l'array interi viene quindi copiato nell'array di input.

  26. utilizzare inarray 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 restituirà -1, se l'elemento non è stato trovato.

  27. rimozione del valore con indice e scheggia!

    function removeArrValue(arr,value) {
        var index = arr.indexOf(value);
        if (index > -1) {
            arr.splice(index, 1);
        }
        return arr;
    }
    
    1. i tuoi ultimi 2 commenti sono stati solo riscrivendo una risposta accettata... si prega di rispondere a un problema risolto solo se avete più informazioni da fornire rispetto a quella accettata. in caso contrario, basta votare la risposta accettata.
  28. se dovete supportare le vecchie versioni di Internet & nbsp; Explorer, vi consiglio di utilizzare il seguente polyfill (nota: questo non è un framework). si tratta di una sostituzione 100% backwards-compatibile di tutti i moderni metodi di array (JavaScript 1.8.5 / ECMAScript 5 Array Extras) che funziona per Internet Explorer 6 +, Firefox 1.5 +, Cromo, Safari, & amp; Opera.

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

    1. anche se questo link può rispondere alla domanda, è meglio includere le parti essenziali della risposta qui e fornire il link per riferimento. le risposte solo link possono diventare non valide se la pagina collegata cambia.
    1. purtroppo, Internet (e Stack Overflow) sono pieni di versioni semi-implementate e parzialmente corrette dei metodi di array ES5. questo è interamente il punto del collegamento al polifill. per una riproduzione veramente completa di tutti i comportamenti corretti, non è sufficiente riassumere "le parti essenziali". è necessario implementare tutte le condizioni di bordo pure. riprodurre il loro contenuto nella sua interezza è ben oltre l'ambito di Stack Overflow. stack Overflow non è GitHub.
  29. ci sono molte risposte fantastiche qui, ma per me, quello che ha funzionato più semplicemente non è stato rimuovere completamente il mio elemento dall'array, ma semplicemente impostando il valore di esso a zero. questo funziona per la maggior parte dei casi che ho, ed è una buona soluzione in quanto userò la variabile più tardi e non voglio andare, solo vuoto per ora. inoltre, questo approccio è completamente cross-browser compatibile.

    array.key = null;
    
  30. se si dispone di oggetti complessi nell'array è possibile utilizzare i filtri? in situazioni in cui $.inArray o array.splice non è così facile da usare. soprattutto se gli oggetti sono forse poco profondi nell'array.

    ad es. per esempio se si dispone di un oggetto con un campo Id e si desidera rimuovere l'oggetto da una serie:

    this.array = this.array.filter(function(element, i) {
        return element.id !== idToRemove;
    });
    
    1. questo è come mi piace farlo. utilizzando una funzione di freccia può essere un one-liner. sono curioso di vedere le prestazioni. vale anche nulla che questo sostituisce l'array. qualsiasi codice con un riferimento al vecchio array non noterà la modifica.
  31. puoi usare lodash _ .pull (array mutato), _ .pullAt (array mutato) o _ .without (non cambia 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']
    
    1. @some-non-descript-user Hai ragione. ma molti utenti come me vengono qui alla ricerca di una risposta generale non solo per gli OP.
    1. @ChunYang Hai assolutamente ragione. sto già usando lodash, perché non solo usarlo se si risparmia tempo.
  32. il seguente metodo rimuoverà tutte le voci di un dato valore da un array senza creare un nuovo array e con una sola iterazione superveloce. e funziona in Internet & nbsp antico; Explorer 5.5 browser:

    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>

  33. rimuovere l'ultima occorrenza o tutte le occorrenze, o la prima occorrenza?

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

    o o o o o

    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
      }
    }
    
  34. con la mia soluzione è possibile rimuovere uno o più elementi in un array grazie a JavaScript puro. non c'è bisogno di un'altra libreria 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]
    
  35. Vanilla JavaScript (ES5.1) - in edizione piazza

    supporto del browser: Internet & nbsp; Explorer & nbsp; 9 o più tardi (supporto dettagliato del browser)

    /**
     * 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) - edizione immutabile

    supporto del browser: stessa vaniglia JavaScript in edizione luogo

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

    vaniglia ES6 - edizione immutabile

    supporto del browser: cromo 46, Bordo 12, Firefox 16, Opera 37, Safari 8 (supporto dettagliato del browser)

    /**
     * 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;
    }
    
    1. si noti che .filter restituisce un nuovo array, che non è esattamente lo stesso che rimuove l'elemento dallo stesso array. il vantaggio di questo approccio è che è possibile catena metodi di array insieme. ad esempio: [1,2,3].filter(n => n%2).map(n => n*n) === [ 1, 9 ]
    1. grande, se ho 600k elementi in array e voglio rimuovere prima 50k, potete immaginare che lentezza? questa non è una soluzione, c'è bisogno di funzione che basta rimuovere elementi e restituisce nulla.
    1. @bjfletcher Questo è ancora meglio, in fase di rimozione, basta allocare 50K elementi e li gettano da qualche parte. (con slice 550K elementi, ma senza gettarli dalla finestra).
    1. preferisco la risposta di bjfletcher, che potrebbe essere breve come items= items.filter(x=>x!=3). inoltre, il OP non ha dichiarato alcun requisito per grandi set di dati.
  36. penso che molte delle istruzioni JavaScript non sono ben pensato per la programmazione funzionale. Splice restituisce l'elemento cancellato in cui la maggior parte del tempo è necessario l'array ridotto. questo è male.

    immagina di fare una chiamata ricorsiva e di dover passare un array con un elemento in meno, probabilmente senza l'elemento indicizzato corrente. oppure immagina di fare un'altra chiamata ricorsiva e di dover passare un array con un elemento spinto.

    in nessuno di questi casi si può fare myRecursiveFunction(myArr.push(c)) o myRecursiveFunction(myArr.splice(i,1)). il primo idiota infatti passerà la lunghezza dell'array e il secondo idiota passerà l'elemento cancellato come parametro.

    quindi quello che faccio in realtà... Per l'eliminazione di un elemento di array e passando il risultato di una funzione come parametro allo stesso tempo faccio come segue

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

    quando si tratta di spingere che è più stupido... a me piace,

    myRecursiveFunction((myArr.push(c),myArr))
    

    credo che in un linguaggio funzionale appropriato un metodo che muta l'oggetto su cui è invocato debba riportare come risultato un riferimento all'oggetto stesso.

  37. 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;
    }
    
  38. è possibile utilizzare eliminare, ma non rearange l'indice, invece si imposta questo slot a 'indefinito × 1'. per esempio: Var list = [1,2,3,4,5,6] - > delete list [1] - > [1, undefined × 1, 3, 4, 5, 6].
  39. USA 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>

  40. delete dovrebbe essere più performante nel breve termine, perché non dovrà spostare gli elementi successivi. forEach, map e filter salta automaticamente l'elaborazione per elementi non definiti (eliminati). ma probabilmente non è l'ideale se si sarà aggiunta un sacco di cose al vostro array in futuro, o la lettura molte volte.
  41. ho fatto una estensione abbastanza efficiente alla base matrice JavaScript:

    Array.prototype.drop = function(k) {
      var valueIndex = this.indexOf(k);
      while(valueIndex > -1) {
        this.removeAt(valueIndex);
        valueIndex = this.indexOf(k);
      }
    };
    
    1. inoltre, nessuna removeAt nello standard ES. suppongo, questa è qualche roba IE-only? questo dovrebbe essere menzionato in risposta.
  42. è possibile utilizzare ES6.

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

    uscita::

    ["1", "2", "4", "5", "6"]
    
    1. questa risposta è bella perché crea una copia dell'array originale, invece di modificare l'originale direttamente.
    1. nota: Array.prototype.filter è ECMAScript 5.1 (No IE8).

      per soluzioni più specifiche: https://stackoverflow.com/a/54390552/8958729

  43. ES6 & amp; senza mutazione: (ottobre 2016)

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

    allora: allora:

    removeByIndex([33,22,11,44],1) //=> [33,11,44]
    
    1. fino a fino a uuuuuuuuuuuuuuuuup! questo è più aggiornato questo dovrebbe N ° 1 risposta non N ° 20!!!
  44. mentre la maggior parte delle risposte di cui sopra rispondere alla domanda, non è abbastanza chiaro perché il metodo slice() non è stato utilizzato. sì, filter() soddisfa i criteri di immutabilità, ma come fare il seguente equivalente più breve:

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

    e ora diciamo che dovremmo rimuovere il secondo elemento dall'array, possiamo semplicemente fare: const newArray = myArray.slice(0,1).concat(myArray.slice(2,4)); // [1,3,4]

    questo modo di cancellare un elemento da un array è fortemente incoraggiato oggi nella comunità a causa della sua natura semplice e immutabile. in generale, i metodi che causano mutazioni dovrebbero essere evitati. ad esempio, si consiglia di sostituire push() con concat() e splice() con slice()

  45. ecco un benchmark delle prestazioni delle due principali possibilità: http://jsben.ch/#/b4Ume
  46. ho fatto una funzione

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

    e usato così.

    pop(valuetoremove,myarray);
    

    saluti!!

    1. se avete intenzione di nominarlo pop almeno farlo fare ciò che il nome del metodo implica!
  47. rimuovere un valore, usando il confronto libero, senza cambiare array originale, 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;
    }
    
  48. Rimuovi elemento all'indice i, senza modificare l'array originale:

    /**
    * 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);
    }
    
  49. 2017-05-08

    la maggior parte delle risposte date funzionano per un confronto rigoroso, il che significa che entrambi gli oggetti fanno riferimento allo stesso oggetto in memoria (o sono tipi primitivi), ma spesso si desidera rimuovere un oggetto non primitivo da un array che ha un certo valore. per esempio, se si effettua una chiamata ad un server e si desidera controllare un oggetto recuperato contro un oggetto locale.

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

    ci sono implementazioni alternative / più veloci per i valoriAreEqual, ma questo fa il lavoro. è inoltre possibile utilizzare un comparatore personalizzato se si dispone di un campo specifico da controllare (ad esempio, alcuni UUID recuperati vs un UUID locale).

    si noti inoltre che si tratta di un'operazione funzionale, il che significa che non cambia l'array originale.

    1. mi piace l'idea, basta pensare è un po 'lento per fare due stringhe per elemento sull'array. comunque ci sono casi in cui vale la pena, grazie per la condivisione.
    1. grazie, ho aggiunto una modifica per chiarire che i valori AreEqual può essere sostituito. sono d'accordo che l'approccio JSON è lento - ma funzionerà sempre. dovrebbe sicuramente utilizzare un confronto migliore, quando possibile.
  50. OK, per esempio hai l'array qui sotto:

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

    e vogliamo eliminare il numero 4, si può semplicemente fare il seguente codice:

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

    se si riutilizza questa funzione, si scrive una funzione riutilizzabile che sarà allegata alla funzione Native array come di seguito:

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

    ma che ne dite se avete l'array qui sotto con pochi [5] nell'array?

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

    abbiamo bisogno di un ciclo per controllare tutti, ma modo più semplice e più efficiente è utilizzando built-in funzioni JavaScript, quindi scriviamo una funzione che utilizza il filtro come di seguito, invece:

    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]
    

    ci sono anche librerie di terze parti che ti aiutano a farlo, come Lodash o underscore, per maggiori informazioni guarda lodash _ .pull, _ .pullAt o _ .without.

    1. c'è un piccolo errore di battitura. si prega di correggere. this.splice(num.indexOf(x), 1); = > this.splice(this.indexOf(x), 1);
    1. si prega di non aumentare built-ins (allegare funzioni di Array.prototipo) in JavaScript. questo è ampiamente considerato come cattiva pratica.
    1. sono d'accordo che non è la cosa migliore da fare nel mondo, ma in questo caso come si potrebbe passare giù alla funzione?
    1. si dovrebbe controllare l'indice. se index = -1, la spline (-1,1) rimuoverà l'ultimo elemento
  51. rimuovere dall'indice

    funzione che restituisce una copia di array senza l'elemento all'indice.

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

    rimuovere da Valore

    funzione che restituisce una copia di array senza il Valore.

    /**
    * 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]
    
    1. le costruzioni ridondanti sono la norma intorno agli sviluppatori web? ho qualcuno sul lavoro che spruzza roba come questo dappertutto. perché non solo return value != elem?!
  52. ci sono già un sacco di risposte, ma perché nessuno ha fatto con un solo liner ancora, Ho pensato di mostrare il mio metodo. sfrutta il fatto che la funzione string.split () rimuove tutti i caratteri specificati durante la creazione di un array. ecco un esempio:

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

    in questo esempio, tutti i 4 sono stati rimossi dall'array ary. tuttavia, è importante notare che qualsiasi array contenente il carattere "-" causerà problemi con questo esempio. in breve, farà sì che la funzione join ("-") unisca impropriamente la stringa. in una tale situazione, tutte le stringhe "-" nel frammento di cui sopra possono essere sostituite con qualsiasi stringa che non verrà utilizzata nell'array originale. ecco un altro esempio:

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

    1. potete vedere che ci sono stringhe nel secondo esempio che ho fornito? non sono sicuro di cosa intendi con questo? l'unico problema è se la stringa contiene uno dei caratteri utilizzati nella separazione, come ho detto nella mia risposta.
    1. metodo interessante, è possibile utilizzare caratteri Unicode per la divisione (ad esempio '\uD842') invece. per renderlo più chiaro e più breve per gli altri, aggiungerei solo qualche stringa agli elementi dell'array (incluso '4') e rimuoverei il primo snippet / esempio (la gente potrebbe aver minimizzato perché non ha nemmeno letto la seconda parte).
  53. pubblica il mio codice che rimuove un elemento dell'array e riduce anche la lunghezza dell'array.

    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();
    }
    
  54. per chiunque cerchi di replicare un metodo che restituisca un nuovo array che abbia i numeri duplicati o le stringhe rimosse, questo è stato messo insieme dalle risposte esistenti:

    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;
    }
    
  55. var ar1 = [1,2,3,4,5,6,7,8,9]
    var toBeRemoved = 2;
    ar1.splice( (ar1.length -toBeRemoved) , toBeRemoved);
    
    1. sarà sempre rimuovere elementi totali n dall'ultimo indice di array. se si conosce l'indice della voce da eliminare, fare qualcosa di simili-

      lasciate AR1 = [1,2,3,4,5,6,7,8,9]; ar1.split (daIndex, come ManyToBeDelete);

      per ulteriori chiarimenti segui il link: https://stackoverflow.com/a/54390552/8958729

  56. che vergogna avete una serie di interi, non un oggetto in cui le chiavi sono equivalenti stringa di questi interi.

    ho esaminato un sacco di queste risposte e tutti sembrano utilizzare "forza bruta" per quanto posso vedere. non ho esaminato ogni singolo, mi scuso se non è così. per un allineamento smallish questo è benissimo, ma che cosa se avete 0000s dei interi in esso?

    correggimi se sbaglio, ma non possiamo supporre che in una mappa key => value, del tipo che un oggetto JS è, il meccanismo di recupero chiave possa essere considerato altamente ingegnerizzato e ottimizzato? (NB se qualche super-esperto mi dice che questo non è il caso, posso suggerire di utilizzare la classe Mappa di ES6, che certamente sarà).

    sto solo suggerendo che, in alcune circostanze, la soluzione migliore potrebbe essere quella di convertire il vostro array in un oggetto... il problema è, naturalmente, che si potrebbe avere la ripetizione di valori interi. suggerisco di mettere quelli in secchi come la parte "valore" delle voci key => value. (NB se sei sicuro di non avere elementi di array ripetuti questo può essere molto più semplice: valori "stessi come" chiavi, e basta andare Object.values(...) per tornare il vostro array modificato).

    così si potrebbe fare:

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

    uscita::

    Object [ <1 empty slot>, Array1, Array[2], Array1, Array1, <5 empty slots>, 46 more… ]

    è quindi facile eliminare tutti i numeri 55

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

    non è necessario eliminarli tutti: i valori di indice sono spinti nei loro secchi in ordine di aspetto, così (per esempio):

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

    cancellerà rispettivamente la prima e l'ultima occorrenza. Lei può contare la frequenza di caso facilmente, sostituire tutti i 55s con 3s trasferendo il contenuto di un secchio all'altro, eccetera.

    ... ritornare al tuo array int modificato è leggermente coinvolto: ma ogni bucket contiene l'indice (nell'array originale) del valore rappresentato dalla chiave (string). ognuno di questi valori di bucket è anche unico: così li si trasformano in chiavi in un nuovo oggetto, con il numero intero (reale) dal "integer string key" come valore... poi ordinare i tasti e andare Object.values( ... ).

    questo suona molto coinvolto e richiede molto tempo... ma ovviamente tutto dipende dalle circostanze e l'utilizzo desiderato. la mia comprensione è che tutte le versioni e i contesti di JS operano solo in un thread, e il thread non "lascia andare", quindi ci potrebbe essere qualche congestione orribile con un metodo "forza bruta": causato non tanto dai indexOf ops, ma ripetuti più slice / splice ops.


    addendum
    Se siete sicuri che questo è troppo ingegneria per il vostro caso d'uso sicuramente il più semplice approccio "forza bruta" è

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

    (sì, altre risposte hanno individuato Array.prototype.filter...)

  57. non dovresti mai cambiare il tuo array. poiché questo è contro il modello di programmazione funzionale. quello che si può fare è creare un nuovo array senza fare riferimento alla matrice che si desidera modificare i dati di utilizzare il metodo ES6 filter;

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

    supponiamo che si desidera rimuovere 5 dalla matrice si può semplicemente farlo in questo modo.

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

    questo vi darà un nuovo array senza il valore che si voleva rimuovere. così il risultato sarà

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

    per ulteriori informazioni potete leggere la documentazione MDN su Array.filter https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

    1. è meglio essere sicuri di sapere che l'elemento è in array, altrimenti findindex restituisce -1 e di conseguenza rimuove il 9.
  58. ho appena creato un polifill sul Array.prototype via Object.defineProperty per rimuovere un elemento desiderato in un array senza portare ad errori durante l'iterazione su di esso in seguito tramite 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)
    }
    

    rimozione di un valore intero

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

    rimozione di un valore stringa

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

    rimozione di un valore booleano

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

    è anche possibile rimuovere un oggetto all'interno dell'array tramite questo metodo Array.prototype.remove. è sufficiente specificare il key => value del Object che si desidera rimuovere.

    rimozione di un valore oggetto

    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}]
    
  59. implementazione molto ingenuo sarebbe il seguente:

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

    ritorno la lunghezza dell'array dalla funzione per rispettare gli altri metodi come Array.prototype.push().

  60. let array = [5,5,4,4,2,3,4]    
    let newArray = array.join(',').replace('5','').split(',')
    

    questo esempio funziona se si desidera rimuovere un elemento corrente.

  61. la vostra domanda non ha indicato se l'ordine o i valori distinti sono un requisito.

    se non ti interessa l'ordine, e non avrà lo stesso valore nel contenitore più di una volta, utilizzare un Set. sarà molto più veloce e più succinta.

    var aSet = new Set();
    
    aSet.add(1);
    aSet.add(2);
    aSet.add(3);
    
    aSet.delete(2);
    
  62. qui ci sono alcuni modi per rimuovere un elemento da un array utilizzando JavaScript.

    tutto il metodo descritto non cambia l'array originale, e invece ne crea uno nuovo.

    se si conosce l'indice di un elemento

    supponiamo di avere un array, e si desidera rimuovere un elemento in posizione i.

    un metodo è quello di utilizzare slice():

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

    slice() crea un nuovo array con gli indici che riceve. creiamo semplicemente un nuovo array, dall'inizio all'indice che vogliamo rimuovere, e concateniamo un altro array dalla prima posizione dopo quella che abbiamo rimosso fino alla fine dell'array.

    se conosci il valore

    in questo caso, una buona opzione è quella di utilizzare filter(), che offre un approccio più dichiarativo:

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

    questo utilizza le funzioni della freccia ES6. è possibile utilizzare le funzioni tradizionali per supportare i browser più vecchi:

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

    oppure è possibile utilizzare Babel e trasporre il codice ES6 di nuovo a ES5 per renderlo più digeribile per i vecchi browser, ma scrivere JavaScript moderno nel vostro codice.

    rimozione di più elementi

    e se invece di un singolo elemento, si desidera rimuovere molti elementi?

    troviamo la soluzione più semplice.

    per indice

    è sufficiente creare una funzione e rimuovere elementi in serie:

    const items = ['a', 'b', 'c', 'd', 'e', 'f']
    
    const removeItem = (items, i) =>
      items.slice(0, i-1).concat(items.slice(i, items.length))
    
    let filteredItems = removeItem(items, 3)
    filteredItems = removeItem(filteredItems, 5)
    //["a", "b", "c", "d"]
    
    console.log(filteredItems)

    per valore

    è possibile cercare l'inclusione all'interno della funzione callback:

    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)

    evitare di cambiare l'array originale

    splice() (da non confondere con slice()) cambia l'array originale, e dovrebbe essere evitato.

    (originariamente pubblicato su https://flaviocopes.com/how-to-remove-item-from-array/)

    1. penso che nel tuo esempio vuoi items.slice(0, i).concat(items.slice(i+1, items.length)), (0, i) invece di (0, i-1) perché l'elemento 'end' dell'array non è incluso nel risultato. inoltre, i + 1 è ok per la seconda parte in quanto restituisce un array vuoto se va fuori dai limiti.
    1. hai ragione. ho fissato che sul mio blog qualche tempo fa, ma mai cambiato nella risposta! grazie per avermi detto
  63. definire un metodo denominato remove () sugli oggetti array utilizzando la funzione di prototipazione di JavaScript.

    Use splice() method to fulfill your requirement.

    per favore date un'occhiata al codice qui sotto.

    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 ]
    

    Note: Below is the full example code executed on Node.js REPL which describes the use of push(), pop(), shift(), unshift() and splice() methods.

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

    grazie.

  64. ho un'altra buona soluzione per rimuovere da un array:

    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/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

  65. eliminare elemento da ultimo

    arrName.pop();
    

    eliminare elemento dal primo

    arrName.shift();
    

    eliminare dal centro

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

    eliminare un elemento dall'ultimo

    arrName.splice(-1);
    

    eliminare utilizzando il numero indice di matrice

     delete arrName[1];
    
  66.     Array.prototype.remove = function(start, end) {
            var n = this.slice((end || start) + 1 || this.length);
            return this.length = start < 0 ? this.length + start : start,
            this.push.apply(this, n)
        }
    

    inizio e fine possono essere negativi, in questo caso contano dalla fine dell'array.
    se viene specificato solo start, viene rimosso un solo elemento.
    la funzione restituisce la nuova lunghezza dell'array.

    z=[0,1,2,3,4,5,6,7,8,9];
    
    newlength=z.remove(2,6);
    

    (8) [, 1, 7, 8, 9]

    z=[0,1,2,3,4,5,6,7,8,9];
    
    newlength=z.remove(-4,-2);
    

    (7) [, 1, 2, 3, 4, 5, 9]

    z=[0,1,2,3,4,5,6,7,8,9];
    
    newlength=z.remove(3,-2);
    

    (4) [, 1, 2, 9]

  67. hai da 1 a 9 array e si desidera rimuovere 5 utilizzare sotto il codice.

    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 si desidera più valore 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 volete rimuovere il valore dell'array in array 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);

    include browser supportato è link

  68. ho avuto questo problema io stesso (in una situazione in cui sostituire l'array era accettabile) e risolto con un semplice:

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

    per dare al frammento di cui sopra un po 'di contesto:

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

    questa soluzione dovrebbe funzionare sia con gli elementi di riferimento che di valore. tutto dipende se è necessario mantenere un riferimento all'array originale per sapere se questa soluzione è applicabile.

  69. voglio rispondere in base a ES6. supponiamo di avere un array come segue:

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

    se vuoi eliminare un indice speciale come 2, scrivi sotto il codice:

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

    ma se volete eliminare un elemento speciale come 3 e non si conosce il suo indice fare come sotto:

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

    suggerimento: si prega di utilizzare una funzione freccia per il filtro callback a meno che non si ottiene un array vuoto.

    1. @Dejan.S, Ho sorpreso, qual è il vostro array, e ciò che si desidera omettere dal vostro array?
    1. era il mio male, ho usato la funzione regolare e ha dovuto fare esplicitamente una dichiarazione di ritorno. ci dispiace per questo:)
    1. @Dejan.S, Ho modificato la risposta per alcuni errori come il vostro errore e aggiungere un suggerimento, se mi downvote, si può votare ora.
  70. un'altra risposta, per me la più semplice è la migliore, e come siamo nel 2018 (vicino al 2019) ti do questo (vicino) un liner per rispondere alla domanda originale:

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

    la cosa utile è che si può usare in un'espressione curry come:

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

  71. var arr =[1,2,3,4,5];
    
    arr.splice(0,1)
    
    console.log(arr)
    

    uscita [2, 3, 4, 5];

  72. rimuovere un particolare elemento / stringa da un array può essere fatto in un unico liner: penso ancora che questo sia il liner più elegante che si possa ottenere per questo tipo di problema:

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

    dove 'theArray' è l'array che si desidera rimuovere qualcosa di particolare, e 1 è la quantità di elementi che si desidera rimuovere.

    1. questa è la risposta che ha funzionato per me quando si cerca di aggiornare un array basato su pulsante radio ggling.
    1. attenzione, se "stringToRemoveFromArray" non si trova il vostro in array, questo rimuoverà l'ultimo elemento di array.
  73. per rimuovere elementi particolari o elementi successivi, il metodo Array.splice () funziona bene. il metodo splice () modifica il contenuto di un array rimuovendo o sostituendo gli elementi esistenti e / o aggiungendo nuovi elementi e restituisce gli elementi rimossi.

    sintassi: array.splice (indice, deleteCount, Item1,....., itemX)

    qui index è obbligatorio e gli argomenti di riposo sono opzionali.

    per esempio:

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

    nota: il metodo Array.splice () può essere utilizzato se si conosce l'indice dell'elemento che si desidera eliminare. ma possiamo avere alcuni casi in più come accennato sotto -

    1. nel caso in cui si desidera eliminare solo ultimo elemento, è possibile utilizzare Array.pop ()

    2. nel caso in cui si desidera eliminare solo il primo elemento, è possibile utilizzare Array.shift ()

    3. se conosci solo l'elemento ma non la posizione (o l'indice) dell'elemento, e vuoi eliminare tutti gli elementi corrispondenti usando il metodo Array.filter ():

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

    o utilizzando scheggia () metodo as-

    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]
    

    o supponiamo di voler cancellare del dall'Array arr:

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

    o o o o o

    let del = 4;
    for(var i = arr.length - 1; i >= 0; i--) {
        if(arr[i] === del) {
           arr.splice(i, 1);
        }
    }
    
    1. se conosci solo l'elemento, ma non la posizione (o l'indice) dell'elemento, e vuoi eliminare solo il primo elemento di corrispondenza utilizzando il metodo 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]
      
  74. il metodo splice () modifica il contenuto di un array rimuovendo o sostituendo gli elementi esistenti e / o aggiungendo nuovi elementi.

    array.splice (inizio [, deleteCount [, Item1 [, item2 [,...]]])

    inizio inizio inizio inizio inizio

    indice a cui iniziare a cambiare l'array (con origine 0). se maggiore della lunghezza dell'array, l'indice iniziale effettivo sarà impostato sulla lunghezza dell'array. se negativo, inizierà che molti elementi dalla fine dell'array (con origine -1) e saranno impostati su 0 se il valore assoluto è maggiore della lunghezza dell'array.

    deleteCount opzionale

    un intero che indica il numero di vecchi elementi di array da rimuovere. se deleteCount viene omesso, o se il suo valore è maggiore di array.length - start (cioè, se è maggiore del numero di elementi rimasti nell'array, a partire dall'inizio), tutti gli elementi dall'inizio alla fine dell'array verranno eliminati. se deleteCount è 0 o negativo, non vengono rimossi elementi. in questo caso, si dovrebbe specificare almeno un nuovo elemento (vedi sotto).

    Item1, articolo 2,... opzionale opzionale

    gli elementi da aggiungere all'array, a partire dall'indice iniziale. se non si specificano elementi, splice () rimuoverà solo elementi dall'array.

    per ulteriori riferimenti si prega di passare attraverso:

    https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice

  75. prendendo profitto di ridurre il metodo come segue:

    caso a) se è necessario rimuovere elemento per indice:

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

    caso b) se è necessario rimuovere un elemento dal valore dell'elemento (int):

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

    così in questo modo possiamo restituire un nuovo array (sarà un modo funzionale fresco - molto meglio che usare push o splice) con l'elemento rimosso.

  76. splice, filtro ed eliminazione per rimuovere elementi da array

    ogni array ha il loro indice e aiuta a eliminare particolare elemento con il loro indice.

    il metodo Splice ()

    array.splice (indice, 1); 1 ° parametro è indice e il secondo è il numero di elementi

    desidera cancellare da quell'indice.

    quindi per singolo elemento usiamo 1.

    il metodo di cancellazione

    cancella array [indice]

    il metodo del filtro ()

    se si desidera eliminare elemento che viene ripetuto in array quindi filtrare l'array.

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

    dove elem è l'elemento che vuoi rimuovere da array e array è il tuo nome array

  77. spesso è meglio creare un nuovo array con la funzione filtro.

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

    questo migliora anche la leggibilità imho. non sono un fan di slice, anche se a volte si dovrebbe andare per esso.

  78. var array = [1,2,3];
    console.log('Array-First',array); // Array-First 1,2,3
    array.splice(1,1);
    console.log('Array-Second',array); // Array-Second 1,3

More similar articles:

  • come rimuovere un elemento da un array in particolare posizione in AngularJS/javascript
  • come rimuovere particolare nome della classe da un elemento selezionato in VueJs?
  • come posso rimuovere i file CSS caricati tramite $ocLazyLoad da un particolare stato ui-router?
  • rimuovere particolare chiave = > valore da array php
  • come rimuovere particolare linea da un mucchio di pagine html?
  • come rimuovere oggetti da array in particolare indice
  • come rimuovere una particolare stringa dalla stringa
  • come rimuovere il tempo dal formato datetime in particolare elemento xml?
  • come rimuovere particolare stringa ripetuta dalla stringa grande
  • non in grado di rimuovere elemento a particolare indice da adattatore array
  • come rimuovere un particolare elemento ripetuto dopo il primo da un vettore di caratteri
  • come rimuovere particolare valore dalla lista di array e anche i suoi prossimi due valori base su una condizione iterator usinng su arraylist?
  • JavaScript rigex per rimuovere particolare testo di formato dalla stringa
  • come rimuovere particolare tag da file XML utilizzando Powershell?
  • come rimuovere tag dt in forma zend per un campo particolare
  • come rimuovere una particolare attività da stack indietro Android?
  • come rimuovere tutti gli spazi da una variabile che non compare accanto a un particolare simbolo?
  • controllare e rimuovere una particolare stringa da array nsmutable senza indice
  • come fare gulp rimuovere i file eliminati durante la visione su un particolare modello glob?
  • come rimuovere il layout dell'applicazione da un particolare Ruby sulla pagina Rails?
  • come rimuovere particolare chiave in FireBase utilizzando Objective-C?
  • rimuovere classe css contenente una particolare stringa
  • come rimuovere i gruppi dal ruolo del progetto (Ex- Users Role) in particolare il progetto utilizzando la chiamata API
  • come rimuovere il ruolo di un utente da particolare risorsa in node_acl?
  • come rimuovere la barra di stato dal controller di vista particolare?
  • come rimuovere la chiave unica nel particolare campo della tabella mysql
  • come rimuovere o nascondere una particolare colonna in un databile?
  • rimuovere solo le righe il cui campo particolare è vuoto
  • come rimuovere bene che era in layout in particolare pagina in ZF2
  • come posso rimuovere una parola particolare in una cella di tabella usando Jquery?