У мене є два масиви. Перший масив містить деякі значення, тоді як другий масив містить показники значень, які слід видалити з першого масиву. Наприклад:

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

Я хочу , щоб видалити значення присутні на індексах 0,2,4з valuesArr. Я думав, що власний spliceметод може допомогти, тому я придумав:

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

Але це не спрацювало, тому що після кожного spliceіндексу значень у них valuesArrбули різні. Я міг би вирішити цю проблему, використовуючи тимчасовий масив і скопіювавши всі значення на другий масив, але мені було цікаво, чи існують якісь власні методи, до яких ми можемо передавати кілька індексів, за допомогою яких можна видалити значення з масиву.

Я вважаю за краще рішення jQuery. (Не впевнений, чи можу я grepтут використовувати )

Завжди є звичайний старий forцикл:

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

Пройти removeValFromIndexв зворотному порядку, і ви можете, .splice()не псуючи покажчики елементів, які ще потрібно зняти.

Зверніть увагу на вищесказане, я використовував синтаксис прямолінійного масиву з квадратними дужками для оголошення двох масивів. Це рекомендований синтаксис, оскільки new Array()використання потенційно заплутане, враховуючи, що він відповідає по-різному, залежно від того, скільки параметрів ви передаєте.

EDIT : Щойно побачив ваш коментар до іншої відповіді про масив індексів, не обов'язково в якомусь конкретному порядку. Якщо це так, просто відсортуйте його у порядку зменшення перед початком роботи:

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

І дотримуйтесь цього за допомогою будь-якого $.each()способу циклічного використання // тощо.

Ось такий, який я використовую, коли не збираюся позначити / підкреслити:

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

Не in-placeможна, але можна зробити за допомогою grepта inArrayфункцій jQuery.

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

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

перевірити цю загадку.

Я пропоную вам використовувати 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);

MDN посилання тут

У чистому JS ви можете провести цикл через масив назад, щоб splice()не зіпсувати показники наступних елементів у циклі:

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

Відповідь вважає за потрібне розмістити час з O(n)часом :). Проблема з вирішенням сплайсингу полягає в тому, що внаслідок основної реалізації масиву, який є буквально масивом , кожен spliceвиклик потребує O(n)часу. Це найбільш яскраво виражено, коли ми встановлюємо приклад для використання такої поведінки:

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)

Це видаляє елементи, починаючи з середини до початку, тому кожне видалення змушує js-движок копіювати n/2елементи, у нас (n/2)^2загалом є операції копіювання, що є квадратичним.

Рішення сплайсингу (припускаючи, що isвоно вже сортується у зменшенному порядку, щоб позбутися від накладних витрат) йде так:

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

Однак реалізувати лінійне тимчасове рішення не важко, заново будуючи масив з нуля, використовуючи маску, щоб побачити, чи ми копіюємо елементи чи ні (сортування підштовхне це до O(n)log(n)). Далі йде така реалізація (не що maskбулева обернена для швидкості):

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

Я запускав це на jsperf.com, і навіть n=100метод сплайсингу на 90% повільніше. Для більших nця різниця буде набагато більшою.

Швидкий ES6 один вкладиш:

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

Просте та ефективне (лінійна складність) рішення з використанням фільтра та набору :

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

Великою перевагою цієї реалізації є те, що операція ( hasфункція) пошуку пошуку займає постійний час, швидше, ніж, наприклад, відповідь невади.

Це добре для мене і працює, коли ви видаляєте також з масиву об'єктів:

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

Можливо, існує коротший і ефективніший спосіб написати це, але це справді працює.

Просте рішення за допомогою ES5. Це здається більш прийнятним для більшості програм сьогодні, оскільки багато хто з них більше не хочуть покладатися на jQuery тощо.

Коли індекси для вилучення сортуються у порядку зростання:

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

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

Коли індекси для видалення не сортуються:

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

Ви можете виправити код, замінивши removeValFromIndexна removeValFromIndex.reverse(). Якщо цей масив не гарантує використання порядку зростання, замість цього можна використовувати removeValFromIndex.sort(function(a, b) { return b - a }).

Ось одна з можливостей:

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

Приклад на jsFiddle

MDN на Array.prototype.reduceRight

Якщо ви використовуєте underscore.js , ви можете _.filter()вирішити свою проблему.

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

Крім того, якщо ви намагаєтесь видалити елементи, використовуючи список елементів замість індексів, ви можете просто використовувати _.without(), наприклад:

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

Тепер filteredArrмає бути["V2", "V4", "V5"]

filter + indexOf (IE9 +):

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

Або за допомогою фільтра ES6 + знайти (Edge +):

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

Ось швидко.

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]

Звучить, як застосувати, може бути те, що ви шукаєте.
можливо, щось подібне спрацювало б?

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

Для декількох предметів або унікальних предметів:

Я пропоную вам використовувати Array.prototype.filter

Ніколи не використовуйте indexOf, якщо ви вже знаєте індекс !:

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

Зробіть:

з хешами ... за допомогою 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);

Це працює. Однак ви б створили новий масив у процесі. Не впевнений, хочете ви цього чи ні, але технічно це буде масив, що містить лише ті значення, які ви хотіли.

Ви можете спробувати використати delete array[index]Це не повністю видалить елемент, а скоріше встановлює значення undefined.

Ви можете сконструювати a Setз масиву, а потім створити масив із набору.

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