it-swarm.dev

Come rimuovo un particolare elemento da un array in JavaScript?

Ho una matrice di numeri e sto usando il metodo .Push() per aggiungere elementi ad esso.

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

Devo usare core JavaScript - no frameworks sono permessi.

6816
Walker

Trova il index dell'elemento dell'array che vuoi rimuovere, quindi rimuovi quell'indice con splice .

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

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 in posizione e restituisce un nuovo array contenente gli elementi che sono stati rimossi.

9908
Tom Wadley

Non so come ti aspetti che array.remove(int) si comporti. Ci sono tre possibilità che posso pensare che potresti volere.

Per rimuovere un elemento di una matrice in un indice i:

array.splice(i, 1);

Se si desidera rimuovere ogni elemento con valore number dall'array:

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

Se vuoi solo rendere l'elemento in index i non esiste più, ma non vuoi che gli indici degli altri elementi cambino:

delete array[i];
1011
Peter Olson

Modificato il 2016 ottobre

In questo esempio di codice uso la funzione "array.filter (...)" per rimuovere gli elementi indesiderati dall'array, questa funzione non cambia la matrice originale e ne crea una nuova. Se il tuo browser non supporta questa funzione (ad es. IE prima della versione 9, o Firefox prima della versione 1.5), considera l'utilizzo di il filtro polyfill da Mozilla .

Rimozione dell'oggetto (codice ECMA-262 Edition 5 aka 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 dell'oggetto (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 ]

IMPORTANT ES2015 "() => {}" la sintassi della funzione freccia non è supportata in IE, Chrome prima della versione 45, Firefox prima della versione 22, Safari prima della versione 10. Per usare la sintassi ES2015 nei vecchi browser puoi usare BabelJS


Rimozione di più elementi (codice ES2016)

Un ulteriore vantaggio di questo metodo è la possibilità di 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 ]

IMPORTANT "array.includes (...)" la funzione non è supportata in IE affatto, Chrome prima della versione 47, Firefox prima della versione 43, Safari prima della versione 9 e Edge prima della versione 14 quindi ecco polyfill di Mozilla

Rimozione di più elementi (JavaScript ES2018 sperimentale all'avanguardia)?

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

Provalo tu stesso in BabelJS :)

Riferimento

831
Ujeenator

Dipende se vuoi mantenere un posto vuoto o no.

Se vuoi uno slot vuoto, elimina va bene:

delete array[ index ];

Se non lo fai, dovresti usare il metodo splice :

array.splice( index, 1 );

E se hai bisogno del valore di quell'elemento, puoi semplicemente memorizzare l'elemento dell'array restituito:

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

Nel caso in cui si desideri eseguirlo in un determinato ordine, è possibile utilizzare array.pop() per l'ultimo o array.shift() per il primo (e entrambi restituiscono anche il valore dell'elemento).

E se non si conosce l'indice dell'articolo, è possibile utilizzare array.indexOf( item ) per ottenerlo (in un if() per ottenere un elemento o in un while() per ottenerli tutti). array.indexOf( item ) restituisce l'indice o -1 se non trovato.

383
xavierm02

Un amico stava riscontrando problemi in Internet Explorer 8 , e mi ha mostrato cosa ha fatto. Gli ho detto che era sbagliato, e mi ha detto che ha avuto la risposta qui. La risposta attuale non funzionerà in tutti i browser (ad esempio, Internet Explorer 8) e rimuoverà solo la prima occorrenza dell'elemento.

Rimuovi TUTTE le istanze da un array

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

Fa scorrere all'indietro l'array (poiché gli indici e la lunghezza cambieranno quando gli elementi vengono rimossi) e rimuoverà l'oggetto se viene trovato. Funziona su tutti i browser.

251
Ben Lesh

Ci sono due approcci principali:

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

  2. delete: delete anArray[index];

Fai attenzione quando usi delete per un array. È utile cancellare gli attributi degli oggetti ma non è così buono per gli array. È meglio usare splice per gli array.

Tieni presente che quando usi delete per un array potresti ottenere risultati errati per anArray.length. In altre parole, delete rimuoverà l'elemento ma non aggiornerà il valore della proprietà length.

Puoi anche aspettarti di avere dei buchi nei numeri indice dopo aver usato la cancellazione, ad es. potresti finire con gli indici 1,3,4,8,9,11 e la lunghezza com'era prima di usare delete. In tal caso, tutti i cicli indicizzati for si arresterebbero in modo anomalo, poiché gli indici non sono più sequenziali.

Se sei costretto ad usare delete per qualche ragione, dovresti usare for each loops quando devi fare un ciclo attraverso gli array. Di fatto, evitare sempre l'uso di cicli indicizzati, se possibile. In questo modo il codice sarebbe più robusto e meno soggetto a problemi con gli indici.

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

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

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

rooms = rooms.remByVal('hello')

console.log(rooms)

118
Zirak

Non è necessario utilizzare indexOf o splice. Tuttavia, si comporta meglio se si desidera rimuovere solo un'occorrenza di un elemento. 

Trova e sposta (sposta):

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

Usa indexOf e splice (indexof):

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

Utilizza solo splice (splice):

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

Run-time su nodejs per array con 1000 elementi (media su oltre 10000 esecuzioni):

indexof è circa 10 volte più lento di sposta. Anche se migliorato rimuovendo la chiamata a indexOf in splice, si comporta molto peggio di move

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

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

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

Uso

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

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

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

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 vuoi estendere un oggetto globale, puoi 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 la ragione principale per cui sto postando questo è di avvertire gli utenti contro l'implementazione alternativa suggerita nei commenti su quella pagina (14 dicembre 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;
};

All'inizio sembra funzionare bene, ma attraverso un processo doloroso ho scoperto che fallisce quando si tenta di rimuovere il penultimo elemento di 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);

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

56
Roger

Underscore.js può essere utilizzato per risolvere problemi con più browser. Utilizza i metodi del browser in-build, se presenti. Se sono assenti come nel caso delle versioni precedenti di Internet Explorer, usa i propri metodi personalizzati.

Un semplice esempio per rimuovere elementi dalla matrice (dal sito Web):

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

Puoi farlo facilmente con filter method:

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 dall'array e funziona anche più velocemente della combinazione di slice e indexOf

53
Salvador Dali

Se si desidera una nuova matrice con le posizioni eliminate rimosse, è sempre possibile eliminare l'elemento specifico e filtrare la matrice. Potrebbe essere necessaria un'estensione dell'oggetto array per i browser che non implementano il metodo di filtro ma a lungo termine è più facile poiché tutto ciò che fai è 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]

42
Loupax

Puoi usare ES6. 

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

Produzione : 

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

Dai un'occhiata a 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);
35
Ekramul Hoque

Puoi usare lodash _.pull (array di matrici), _.pullAt (array di matrici) o _.without (non muta l'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']
33
Chun Yang

OK, per esempio stai avendo l'array di seguito:

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

E vogliamo eliminare il numero 4, puoi semplicemente fare il codice seguente:

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

Se si riutilizza questa funzione, si scrive una funzione riutilizzabile che verrà associata alla funzione di array nativo 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 dici se stai usando l'array sottostante con pochi [5] s nella matrice?

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

Abbiamo bisogno di un ciclo per controllarli tutti, ma il modo più semplice ed efficiente è utilizzare le funzioni JavaScript incorporate, 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]

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

32
Alireza

Sono abbastanza nuovo su JavaScript e avevo bisogno di questa funzionalità. Ho solo scritto questo:

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

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

Output - Come previsto . ["Item1", "item1"]

Potresti avere esigenze diverse da me, quindi puoi facilmente modificarlo per adattarle. Spero che questo aiuti qualcuno.

27
sofiax

ES6 e senza mutazione: (ottobre 2016)

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

Poi : 

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

Aggiornamento: Questo metodo è consigliato solo se non è possibile utilizzare ECMAScript 2015 (precedentemente noto come ES6). Se puoi usarlo, altre risposte qui forniscono implementazioni molto più ordinate.


Questo Gist qui risolverà 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:

var x = [1, 2, 3, 3, true, false, undefined, false];

x.destroy(3);         // => 3
x.destroy(false);     // => false
x;                    // => [1, 2, true, undefined]

x.destroy(true);      // => true
x.destroy(undefined); // => undefined
x;                    // => [1, 2]

x.destroy(3);         // => null
x;                    // => [1, 2]
22
zykadelic

Se hai oggetti complessi nell'array puoi usare i filtri? In situazioni in cui $ .inArray o array.splice non è così facile da usare. Soprattutto se gli oggetti sono forse superficiali nell'array.

Per esempio. se hai un oggetto con un campo Id e vuoi che l'oggetto venga rimosso da un array:

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

Ecco alcuni modi per rimuovere un elemento da un array usando JavaScript.

Tutto il metodo descritto non modifica l'array originale, e ne crea uno nuovo.

Se conosci l'indice di un articolo

Supponiamo di avere un array e di voler rimuovere un oggetto in posizione i.

Un metodo è usare slice():

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

console.log(filteredItems)

slice() crea una nuova matrice 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 che segue quella che abbiamo rimosso alla fine dell'array.

Se conosci il valore

In questo caso, una buona opzione è usare 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 freccia ES6. Puoi 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 puoi usare Babel e trasferire il codice ES6 in ES5 per renderlo più digeribile per i vecchi browser, ma scrivere codice JavaScript moderno nel tuo codice.

Rimozione di più oggetti

Cosa succede se al posto di un singolo oggetto, vuoi rimuovere molti oggetti?

Scopriamo la soluzione più semplice.

Per indice

Puoi semplicemente 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)

In base al valore

Puoi cercare l'inclusione all'interno della funzione di 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 modificare l'array originale

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

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

20
Flavio Copes

Non dovresti mai mutare il tuo array nel tuo array. Poiché ciò è contrario al modello di programmazione funzionale. Quello che puoi fare è creare un nuovo array senza fare riferimento alla matrice che vuoi modificare i dati usando il metodo es6 filter;

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

Supponiamo che tu voglia rimuovere 5 dall'array, puoi semplicemente farlo in questo modo.

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

Questo ti darà un nuovo array senza il valore che volevi rimuovere. Quindi il risultato sarà

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

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

19
Adeel Imran

Un approccio più moderno, ECMAScript 2015 (precedentemente noto come Harmony o ES 6). Dato:

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

Poi:

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

Cedendo: 

[1, 2, 4]

Puoi utilizzare Babel e un polyfill service per assicurarti che sia supportato dai browser.

18
bjfletcher

So che ci sono già molte risposte, ma molte sembrano complicare troppo il problema. Ecco un modo semplice e ricorsivo per rimuovere tutte le istanze di una chiave: chiama self fino a quando l'indice non viene trovato. Sì, funziona solo nei browser con indexOf, ma è semplice e può essere facilmente riempito.

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

Ho un'altra buona soluzione per la rimozione 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

15
Aram Grigoryan

Puoi fare un ciclo inverso per assicurarti di non rovinare 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);
}

Dimostrazione dal vivo

15
Jeff Noel

Sulla base di tutte le risposte che erano principalmente corrette e tenendo conto delle migliori pratiche suggerite (specialmente non usando direttamente Array.prototype), ho trovato 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;
}

Rivedendo la funzione di cui sopra, nonostante il fatto che funzioni bene, ho capito che ci potrebbe essere un miglioramento delle prestazioni. Anche 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 usare:

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 confrontato diverse soluzioni per Array senza problemi e ho confrontato il tempo necessario per l'esecuzione. Aggiornerò questa risposta con il link una volta che finirò quel post. Solo per farti sapere, ho confrontato quanto sopra contro il lodash senza e nel caso il browser supporti Map, batte lodash! Si noti che non sto utilizzando Array.prototype.indexOf o Array.prototype.includes poiché il wrapping dei valori exlcude in Map o Object rende l'interrogazione più veloce!

15
Ardi

Hai da 1 a 9 array e vuoi rimuovere 5 usa 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 si desidera 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 il browser supportato è link

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

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

Rimuovi per Indice

Funzione che restituisce una copia dell'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 ]

Rimuovi per valore

Funzione che restituisce una copia dell'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]
13
nsantana

Voglio rispondere basato suES6. Supponi di avere una matrice come la seguente:

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

Se vuoi cancellare un indice speciale come 2, scrivi sotto il codice:

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

Ma se vuoi eliminare un elemento speciale come 3 e non sai che il suo indice fa come sotto:

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

Suggerimento : si prega di utilizzare una funzione freccia per la funzione di richiamo del filtro, a meno che non si ottenga un array vuoto.

11
AmerllicA

Crea nuovo array:

var my_array = new Array();

Aggiungi elementi a questo array:

my_array.Push("element1");

La funzione indexOf (Restituisce indice o -1 quando non trovata):

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

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

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

Rimuovi 1 elemento posizionato all'indice dall'array

my_array.splice(index, 1);
11
Enrico

Ho anche eseguito la situazione in cui ho dovuto rimuovere un elemento da Array. .indexOf non funzionava in IE* quindi condivido la mia soluzione jQuery.inArray() funzionante.

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

2017-05-08

La maggior parte delle risposte fornite funziona per un confronto rigoroso, nel senso che entrambi gli oggetti fanno riferimento allo stesso identico oggetto in memoria (o sono tipi primitivi), ma spesso si desidera rimuovere un oggetto non primitivo da una matrice che ha un determinato valore. Ad esempio, se si effettua una chiamata a un server e si desidera controllare un oggetto recuperato su 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}]

Esistono implementazioni alternative/più veloci per valuesAreEqual, ma questo è il lavoro. È anche possibile utilizzare un comparatore personalizzato se si dispone di un campo specifico da controllare (ad esempio, alcuni UUID recuperati rispetto a un UUID locale).

Si noti inoltre che questa operazione è funzionale, il che significa che non muta l'array originale.

9
Aidan Hoolachan

Penso che molte delle istruzioni JavaScript non siano ben pensate per la programmazione funzionale. Splice restituisce l'elemento eliminato in cui la maggior parte delle volte è necessario l'array ridotto. Questo non va bene.

Immagina di fare una chiamata ricorsiva e passare una matrice con un elemento in meno, probabilmente senza l'elemento indicizzato corrente. Oppure immagina di fare un'altra chiamata ricorsiva e devi passare un array con un elemento premuto.

In nessuno di questi casi puoi 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 eliminato come parametro.

Quindi, cosa faccio di fatto ... Per eliminare un elemento di matrice e passare il risultante a una funzione come parametro allo stesso tempo faccio come segue

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

Quando si parla di Push è più sciocco ... Mi piace,

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

Credo in un linguaggio funzionale appropriato un metodo che muta l'oggetto su cui è chiamato deve restituire un riferimento all'oggetto stesso come risultato.

9
Redu

In CoffeeScript :

my_array.splice(idx, 1) for ele, idx in my_array when ele is this_value
8

Vanilla JavaScript (ES5.1) - in place edition

Supporto browser: Internet Explorer 9 o successivo ( supporto browser dettagliato )

/**
 * 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) - immutable edition

Supporto per browser: identico a quello di Vanilla JavaScript in edizioni

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

    arrayCopy = array.slice();

    return removeInPlace(arrayCopy, item);
}

Vanilla ES6 - immutable edition

Supporto browser: Chrome 46, Edge 12, Firefox 16, Opera 37, Safari 8 ( supporto browser dettagliato )

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

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

Mi piace questa versione di splice, 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);
});
6
mboeckle

È possibile scorrere su ogni array- elemento e splice se esiste nel array.

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

Ho appena creato un polyfill su Array.prototype tramite Object.defineProperty per rimuovere un elemento desiderato in un array senza causare errori durante l'iterazione su di esso successivamente 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. Hai solo bisogno di specificare key => value del Object che vuoi 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}]
5
Victor

Ho fatto un'estensione abbastanza efficiente all'array JavaScript di base:

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

Con la mia soluzione puoi rimuovere uno o più elementi in un array grazie al puro JavaScript. 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]
5
Kamuran Sönecek

Rimuovere un valore, usando un confronto casuale, senza modificare la matrice 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;
}
4
mpen

Ancora un'altra risposta, per me il più semplice è il migliore, e visto che 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) 
}

L'utile è che puoi usarlo in un'espressione curry come:

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

4
Sebastien H.

Mentre la maggior parte delle risposte sopra riportate risponde alla domanda, non è abbastanza chiaro perché il metodo slice() non sia stato usato. Sì, filter() soddisfa i criteri di immutabilità, ma per quanto riguarda 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 eliminare un elemento da un array è fortemente incoraggiato oggi nella comunità a causa della sua natura semplice e immutabile. In generale, i metodi che causano la mutazione dovrebbero essere evitati. Ad esempio, sei invitato a sostituire Push() con concat() e splice() con slice() 

4
Stelios Voskos

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>

4

Rimozione di un particolare elemento/stringa da un array può essere fatto in un unico rivestimento: Continuo a pensare che questo sia il più elegante che si possa ottenere per questo tipo di problema: 

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

dove 'theArray' è l'array da cui vuoi rimuovere qualcosa di particolare.

4

Pubblica il mio codice che rimuove un elemento dell'array in posizione 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();
}
3
hailong

Ci sono molte risposte fantastiche qui, ma per me, ciò che ha funzionato più semplicemente non è stato rimuovere completamente il mio elemento dall'array ma semplicemente impostando il valore di esso su null. Questo funziona per la maggior parte dei casi che ho, ed è una buona soluzione dato che userò la variabile più tardi e non voglio che se ne vada, per ora vuota. Inoltre, questo approccio è completamente compatibile con i browser.

array.key = null;
3
rncrtr

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

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

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

Per chi cerca di replicare un metodo che restituirà un nuovo array con numeri o stringhe duplicati rimossi, 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;
}
3
cjjenkinson

Ho fatto una funzione 

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

E usato in questo modo.

pop(valuetoremove,myarray);

Saluti!

3
Ali Akram

L'implementazione molto ingenua sarebbe la 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);

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

3
Gaurang Patel

Ho avuto questo problema da solo (in una situazione in cui la sostituzione dell'array era accettabile) e l'ho risolto con un semplice:

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

Per dare il 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 con articoli di riferimento e di valore. Dipende tutto se è necessario mantenere un riferimento alla matrice originale per sapere se questa soluzione è applicabile. 

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

Usando Array.findindex, possiamo ridurre il numero di righe di codice.

developer.mozilla.org

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

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

Questa soluzione richiederà un array di input e cercherà attraverso l'input il valore da rimuovere. Questo eseguirà un ciclo attraverso l'intero array di input e il risultato sarà un secondo numero di array che ha rimosso l'indice specifico. L'array di interi viene quindi ricopiato nell'array di input. 

2
penguin

La tua domanda non ha indicato se l'ordine o valori distinti sono un requisito.

Se non ti interessa l'ordine e non avrai lo stesso valore nel contenitore più di una volta, usa un Set. Sarà molto più veloce e più sintetico. 

var aSet = new Set();

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

aSet.delete(2);
2
Steven Spungin
[2,3,5].filter(i => ![5].includes(i))

Rimozione del valore con indice e splicing!

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

cancella l'elemento dall'ultimo 

arrName.pop();

cancella l'elemento dal primo 

arrName.shift();

elimina dal centro

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

Ex: arrName.splice(1,1);

cancella un elemento dall'ultimo

arrName.splice(-1);

Cancellare usando il numero di indice dell'array

 delete arrName[1];
2
Srikrushna Pal

Che peccato avere un array di interi, non un oggetto in cui le chiavi sono equivalenti a stringa di questi numeri interi.

Ho esaminato molte di queste risposte e tutti sembrano usare "forza bruta" per quanto posso vedere. Non ho esaminato ogni singolo, scuse se questo non è così. Per un piccolo array questo va bene, ma cosa succede se ci sono migliaia di interi?

Correggetemi se ho torto, ma non possiamo assumere che in una mappa key => value, del tipo di un oggetto JS, si possa presumere che il meccanismo di recupero delle chiavi sia altamente ingegnerizzato e ottimizzato? (NB se qualche super-esperto mi dice che questo non è il caso, posso suggerire di usare ES6's Map class invece, che certamente sarà).

Sto solo suggerendo che, in alcune circostanze, la soluzione migliore potrebbe essere quella di convertire la matrice in un oggetto ... il problema, naturalmente, è che potresti aver ripetuto valori interi. Suggerisco di mettere quelli in bucket come parte "valore" delle voci key => value. (NB se sei sicuro di non avere alcun elemento di ripetizione dell'array, questo può essere molto più semplice: valori "uguali a" chiavi, e basta andare Object.values(...) per recuperare l'array modificato).

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

produzione:

Object [<1 empty slot>, Array 1 , Array [2], Array 1 , Array 1 , <5 slot vuoto>, 46 altro ...]

è quindi facile cancellare tutti i numeri 55

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

Non è necessario eliminarli tutti: i valori dell'indice vengono inseriti nei rispettivi bucket in ordine di apparizione, quindi (ad esempio):

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

eliminerà rispettivamente la prima e l'ultima occorrenza. Puoi contare facilmente la frequenza dell'occorrenza, sostituire tutti i 55 con 3 secondi trasferendo il contenuto di un secchio all'altro, ecc.

... il recupero dell'array int modificato è leggermente coinvolto: ma ciascun bucket contiene l'indice (nell'array originale) del valore rappresentato dalla chiave (stringa). Ciascuno di questi valori del bucket è anche univoco: quindi li si trasforma in chiavi in ​​un nuovo oggetto, con il numero (reale) intero dalla "chiave stringa intera" come valore ... quindi si ordinano le chiavi e si passa a Object.values( ... ).

Sembra molto complicato e richiede molto tempo ... ma ovviamente tutto dipende dalle circostanze e dall'uso 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 potrebbe esserci qualche orribile congestione con un metodo di "forza bruta": causato non tanto dalle operazioni indexOf , ma più ripetizioni slicesplice ops.

_/Addendum
Se sei sicuro questo è troppo ingegnoso per il tuo 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...)

2
mike rodent

Il seguente metodo rimuoverà tutte le voci di un determinato valore da un array senza creare un nuovo array e con una sola iterazione che è superfast. E funziona in antico Internet 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>

2
Eugene Tiurin

Per rimuovere elementi particolari o elementi successivi, Array.splice () metodo funziona bene . Il metodo splice () modifica il contenuto di un array rimuovendo o sostituendo elementi esistenti e/o aggiungendo nuovi elementi e restituisce l'articolo rimosso (s).

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

Qui index è obbligatorio e gli argomenti di riposo sono facoltativi.

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 potremmo avere alcuni altri casi, come indicato di seguito-

  1. Nel caso in cui desideri eliminare solo l'ultimo elemento, puoi usare Array.pop ()

  2. Nel caso in cui desideri eliminare solo il primo elemento, puoi usare Array.shift ()

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

    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 usando il metodo splice () come-

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]

OR Supponiamo di voler eliminare 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)
}

OR

let del = 4;
for(var i = arr.length - 1; i >= 0; i--) {
    if(arr[i] === del) {
       arr.splice(i, 1);
    }
}
  1. Se conosci l'elemento da solo ma non la posizione (o l'indice) dell'elemento e desideri eliminare solo il primo elemento corrispondente usando 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]
    
1
Chang

Se devi supportare versioni precedenti di Internet Explorer, ti consiglio di usare il seguente polyfill (nota: questo è not un framework). È una sostituzione al 100% compatibile con i precedenti di tutti i moderni metodi di array (JavaScript 1.8.5/ECMAScript 5 Array Extras) che funziona per Internet Explorer 6+, Firefox 1.5+, Chrome, Safari e Opera.

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

1
Matt Brock

Spesso è meglio creare semplicemente un nuovo array con la funzione filtro.

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

Ciò migliora anche la leggibilità imho. Non sono un fan della fetta, anche se a volte sai che dovresti farlo.

1
codepleb

Definire un metodo denominato remove () sugli oggetti array usando la funzione di prototipazione di JavaScript.

Usa splice () metodo per soddisfare i tuoi requisiti.

Si prega di dare 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 ]

Nota: Di seguito è riportato il codice di esempio completo eseguito su Node.js REPL che descrive l'uso di Push (), pop (), shift (), unshift () e splice () metodi.

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

1
hygull

Unire, filtrare ed eliminare per rimuovere l'elemento dall'array

Ogni array ha il suo indice e aiuta a cancellare particolari elementi con il loro indice.

Il metodo splice () 

array.splice (index, 1 ); 1 parametro è index e second è il numero di elemento tu

voglio cancellare da quell'indice.

Quindi per singolo elemento usiamo 1. 

Il metodo delete

cancella array [indice]

Il metodo filter ()

Se si desidera eliminare un elemento ripetuto nell'array, filtrare la matrice.

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

dove elem è l'elemento che si desidera rimuovere dall'array e l'array è il nome dell'array

1
ashish

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

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

inizio

Indice al quale iniziare a cambiare la matrice (con Origine 0). Se maggiore della lunghezza dell'array, l'indice iniziale effettivo verrà impostato sulla lunghezza dell'array. Se negativo, inizierà molti elementi dalla fine dell'array (con Origine -1) e verrà impostato su 0 se il valore assoluto è maggiore della lunghezza dell'array.

deleteCount Facoltativo

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

item1, item2, ... Opzionale

Gli elementi da aggiungere all'array, iniziando dall'indice di partenza. Se non si specifica alcun elemento, splice () rimuoverà solo gli elementi dall'array.

Per ulteriori referene gentilmente passare:

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

0
ashish

Ci sono già molte risposte, ma poiché nessuno l'ha ancora fatto con un solo liner, ho pensato di mostrare il mio metodo. Sfrutta il fatto che la funzione string.split () rimuoverà 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 vengono rimossi dall'array. Tuttavia, è importante notare che qualsiasi array contenente il carattere "-" causerà problemi con questo esempio. In breve, causerà la funzione join ("-") per spezzare la stringa in modo errato. In una situazione del genere, tutte le stringhe "-" nello snipet precedente 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("[email protected]#").split("[email protected]#[email protected]#").join("[email protected]#").split("[email protected]#");
console.log(out);

0
Partial Science

Prendendo profitto di ridurre il metodo come segue:

caso a) se è necessario rimuovere l'elemento per indice:

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

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

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

In questo modo possiamo restituire un nuovo array (sarà un modo funzionale e funzionale - molto meglio di usare Push o splice) con l'elemento rimosso.

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

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

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

arr.splice(0,1)

console.log(arr)

Uscita [2, 3, 4, 5];

0
Shahriar Ahmad