Ho due array. Il primo array contiene alcuni valori mentre il secondo array contiene gli indici dei valori che dovrebbero essere rimossi dal primo array. Per esempio:

var valuesArr = new Array("v1","v2","v3","v4","v5");   
var removeValFromIndex = new Array(0,2,4);

Voglio rimuovere i valori presenti negli indici 0,2,4da valuesArr. Ho pensato che il splicemetodo nativo potesse aiutare, quindi ho pensato :

$.each(removeValFromIndex,function(index,value){
    valuesArr.splice(value,1);
});

Ma non ha funzionato perché dopo ciascuno splice, gli indici dei valori valuesArrerano diversi. Potrei risolvere questo problema utilizzando un array temporaneo e copiando tutti i valori nel secondo array, ma mi chiedevo se ci sono metodi nativi a cui possiamo passare più indici in cui rimuovere i valori da un array.

Preferirei una soluzione jQuery. (Non sono sicuro di poterlo usare grepqui)

C'è sempre il semplice vecchio forloop:

var valuesArr = ["v1","v2","v3","v4","v5"],
    removeValFromIndex = [0,2,4];    

for (var i = removeValFromIndex.length -1; i >= 0; i--)
   valuesArr.splice(removeValFromIndex[i],1);

Procedi removeValFromIndexin ordine inverso e puoi .splice()senza rovinare gli indici degli elementi ancora da rimuovere.

Nota in quanto sopra ho usato la sintassi del letterale array con parentesi quadre per dichiarare i due array. Questa è la sintassi consigliata perché l' new Array()uso è potenzialmente fonte di confusione dato che risponde in modo diverso a seconda di quanti parametri si passano.

EDIT : Ho appena visto il tuo commento su un'altra risposta sull'array di indici non necessariamente in un ordine particolare. In questo caso, ordinalo in ordine decrescente prima di iniziare:

removeValFromIndex.sort(function(a,b){ return b - a; });

E seguilo con qualsiasi $.each()metodo di loop / / ecc.

Eccone uno che uso quando non vado con lodash / underscore:

while(IndexesToBeRemoved.length) {
    elements.splice(IndexesToBeRemoved.pop(), 1);
}

Non in-placema può essere fatto utilizzando grepe le inArrayfunzioni di jQuery.

var arr = $.grep(valuesArr, function(n, i) {
    return $.inArray(i, removeValFromIndex) ==-1;
});

alert(arr);//arr contains V2, V4

controlla questo violino.

Ti suggerisco di utilizzare Array.prototype.filter

var valuesArr = ["v1","v2","v3","v4","v5"];
var removeValFrom = [0, 2, 4];
valuesArr = valuesArr.filter(function(value, index) {
     return removeValFrom.indexOf(index) == -1;
})

function filtermethod(element, index, array) {  
    return removeValFromIndex.find(index)
}  
var result = valuesArr.filter(filtermethod);

Il riferimento MDN è qui

In JS puro puoi scorrere l'array all'indietro, in modo splice()da non rovinare gli indici degli elementi successivi nel ciclo:

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

È necessario pubblicare una risposta con il O(n)tempo :). Il problema con la soluzione di giunzione è che a causa dell'implementazione sottostante dell'array che è letteralmente un array , ogni splicechiamata richiederà O(n)tempo. Questo è più pronunciato quando impostiamo un esempio per sfruttare questo comportamento:

var n = 100
var xs = []
for(var i=0; i<n;i++)
  xs.push(i)
var is = []
for(var i=n/2-1; i>=0;i--)
  is.push(i)

Questo rimuove gli elementi a partire dal centro all'inizio, quindi ogni rimozione forza il motore js a copiare n/2elementi, abbiamo (n/2)^2operazioni di copia in totale che sono quadratiche.

La soluzione di giunzione (supponendo che issia già ordinata in ordine decrescente per eliminare le spese generali) funziona in questo modo:

for(var i=0; i<is.length; i++)
  xs.splice(is[i], 1)

Tuttavia, non è difficile implementare una soluzione temporale lineare, ricostruendo l'array da zero, utilizzando una maschera per vedere se copiamo elementi o meno (l'ordinamento lo spingerà a O(n)log(n)). La seguente è un'implementazione di questo tipo (non che maskè booleano invertito per la velocità):

var mask = new Array(xs.length)
for(var i=is.length - 1; i>=0; i--)
  mask[is[i]] = true
var offset = 0
for(var i=0; i<xs.length; i++){
  if(mask[i] === undefined){
    xs[offset] = xs[i]
    offset++
  }
}
xs.length = offset

L'ho eseguito su jsperf.com e anche n=100il metodo di giunzione è del 90% più lento. Per maggiori nquesta differenza sarà molto maggiore.

Quick ES6 una fodera:

const valuesArr = new Array("v1","v2","v3","v4","v5");   
const removeValFromIndex = new Array(0,2,4);

const arrayWithValuesRemoved = valuesArr.filter((value, i) => removeValFromIndex.includes(i))

Una soluzione semplice ed efficiente (complessità lineare) che utilizza filtri e set :

const valuesArr = ['v1', 'v2', 'v3', 'v4', 'v5'];   
const removeValFromIndex = [0, 2, 4];

const indexSet = new Set(removeValFromIndex);

const arrayWithValuesRemoved = valuesArr.filter((value, i) => !indexSet.has(i));

console.log(arrayWithValuesRemoved);

Il grande vantaggio di questa implementazione è che l'operazione ( hasfunzione) Set lookup richiede un tempo costante, essendo più veloce della risposta di nevace, per esempio.

Questo funziona bene per me e funziona anche quando elimino da un array di oggetti:

var array = [ 
    { id: 1, name: 'bob', faveColor: 'blue' }, 
    { id: 2, name: 'jane', faveColor: 'red' }, 
    { id: 3, name: 'sam', faveColor: 'blue' }
];

// remove people that like blue

array.filter(x => x.faveColor === 'blue').forEach(x => array.splice(array.indexOf(x), 1));

Potrebbe esserci un modo più breve e più efficiente per scrivere questo, ma funziona.

Una soluzione semplice utilizzando ES5. Questo sembra più appropriato per la maggior parte delle applicazioni al giorno d'oggi, dal momento che molti non vogliono più fare affidamento su jQuery ecc.

Quando gli indici da rimuovere sono ordinati in ordine crescente:

var valuesArr = ["v1", "v2", "v3", "v4", "v5"];   
var removeValFromIndex = [0, 2, 4]; // ascending

removeValFromIndex.reverse().forEach(function(index) {
  valuesArr.splice(index, 1);
});

Quando gli indici da rimuovere non sono ordinati:

var valuesArr = ["v1", "v2", "v3", "v4", "v5"];   
var removeValFromIndex = [2, 4, 0];  // unsorted

removeValFromIndex.sort(function(a, b) { return b - a; }).forEach(function(index) {
  valuesArr.splice(index, 1);
});

Puoi correggere il tuo codice sostituendolo removeValFromIndexcon removeValFromIndex.reverse(). Se non è garantito che quell'array utilizzi l'ordine crescente, puoi invece usare removeValFromIndex.sort(function(a, b) { return b - a }).

Ecco una possibilità:

valuesArr = removeValFromIndex.reduceRight(function (arr, it) {
    arr.splice(it, 1);
    return arr;
}, valuesArr.sort(function (a, b) { return b - a }));

Esempio su jsFiddle

MDN su Array.prototype.reduceRight

Se stai usando underscore.js , puoi usare _.filter()per risolvere il tuo problema.

var valuesArr = new Array("v1","v2","v3","v4","v5");
var removeValFromIndex = new Array(0,2,4);
var filteredArr = _.filter(valuesArr, function(item, index){
                  return !_.contains(removeValFromIndex, index);
                });

Inoltre, se stai tentando di rimuovere elementi utilizzando un elenco di elementi anziché gli indici, puoi semplicemente utilizzare _.without(), in questo modo:

var valuesArr = new Array("v1","v2","v3","v4","v5");
var filteredArr = _.without(valuesArr, "V1", "V3");

Ora filteredArrdovrebbe essere["V2", "V4", "V5"]

filtro + indexOf (IE9 +):

function removeMany(array, indexes) {
  return array.filter(function(_, idx) {
    return indexes.indexOf(idx) === -1;
  });
}); 

O con filtro ES6 + trova (Edge +):

function removeMany(array, indexes = []) {
  return array.filter((_, idx) => indexes.indexOf(idx) === -1)
}

Ecco una sveltina.

function removeFromArray(arr, toRemove){
    return arr.filter(item => toRemove.indexOf(item) === -1)
}

const arr1 = [1, 2, 3, 4, 5, 6, 7]
const arr2 = removeFromArray(arr1, [2, 4, 6]) // [1,3,5,7]

Sembra che Applica potrebbe essere quello che stai cercando.
forse qualcosa del genere funzionerebbe?

Array.prototype.splice.apply(valuesArray, removeValFromIndexes );

Per più articoli o un articolo unico:

Ti suggerisco di usare Array.prototype.filter

Non usare mai indexOf se conosci già index !:

var valuesArr = ["v1","v2","v3","v4","v5"];
var removeValFrom = [0, 2, 4];

valuesArr = valuesArr.filter(function(value, index) {
     return removeValFrom.indexOf(index) == -1;
}); // BIG O(N*m) where N is length of valuesArr and m is length removeValFrom

Fare:

con hash ... utilizzando Array.prototype.map

  var valuesArr = ["v1","v2","v3","v4","v5"];
  var removeValFrom = {};
  ([0, 2, 4]).map(x=>removeValFrom[x]=1); //bild the hash.
  valuesArr = valuesArr.filter(function(value, index) {
      return removeValFrom[index] == 1;
  }); // BIG O(N) where N is valuesArr;

var valuesArr = new Array("v1","v2","v3","v4","v5");   
var removeValFromIndex = new Array(0,2,4);

console.log(valuesArr)
let arr2 = [];

for (let i = 0; i < valuesArr.length; i++){
  if (    //could also just imput this below instead of index value
    valuesArr[i] !== valuesArr[0] && // "v1" <--
    valuesArr[i] !== valuesArr[2] && // "v3" <--
    valuesArr[i] !== valuesArr[4]    // "v5" <--
  ){
    arr2.push(valuesArr[i]);
  }
}

console.log(arr2);

Funziona. Tuttavia, nel processo creeresti un nuovo array. Non sono sicuro se questo lo desideri o meno, ma tecnicamente sarebbe un array contenente solo i valori che desideri.

Potresti provare a usare delete array[index]Questo non rimuoverà completamente l'elemento ma piuttosto imposta il valore su undefined.

È possibile costruire un Setarray dall'array e quindi creare un array dall'insieme.

const array = [1, 1, 2, 3, 5, 5, 1];
const uniqueArray = [...new Set(array)];
console.log(uniqueArray); // Result: [1, 2, 3, 5]