видалити об'єкти з масиву за властивістю об'єкта

var listToDelete = ['abc', 'efg'];

var arrayOfObjects = [{id:'abc',name:'oh'}, // delete me
                      {id:'efg',name:'em'}, // delete me
                      {id:'hij',name:'ge'}] // all that should remain

Як я можу видалити об'єкт із масиву шляхом відповідності властивості об'єкта?

Тільки рідний JavaScript, будь ласка.

У мене виникають проблеми з використанням сплайсу, оскільки довжина зменшується з кожним видаленням. Використання клону та сплайсингу на оригінальному індексі все ще залишає вас із проблемою зменшення довжини.

Я припускаю, що ви використовували spliceщось подібне?

for (var i = 0; i < arrayOfObjects.length; i++) {
    var obj = arrayOfObjects[i];

    if (listToDelete.indexOf(obj.id) !== -1) {
        arrayOfObjects.splice(i, 1);
    }
}

Все, що вам потрібно зробити, щоб виправити помилку, - це зменшення iв наступний раз (і цикл назад - також варіант):

for (var i = 0; i < arrayOfObjects.length; i++) {
    var obj = arrayOfObjects[i];

    if (listToDelete.indexOf(obj.id) !== -1) {
        arrayOfObjects.splice(i, 1);
        i--;
    }
}

Щоб уникнути видалення лінійного часу, ви можете записувати елементи масиву, які ви хочете зберегти над масивом:

var end = 0;

for (var i = 0; i < arrayOfObjects.length; i++) {
    var obj = arrayOfObjects[i];

    if (listToDelete.indexOf(obj.id) === -1) {
        arrayOfObjects[end++] = obj;
    }
}

arrayOfObjects.length = end;

і щоб уникнути пошуку в лінійний час у сучасний час виконання, ви можете використовувати хеш-набір:

const setToDelete = new Set(listToDelete);
let end = 0;

for (let i = 0; i < arrayOfObjects.length; i++) {
    const obj = arrayOfObjects[i];

    if (setToDelete.has(obj.id)) {
        arrayOfObjects[end++] = obj;
    }
}

arrayOfObjects.length = end;

яка може бути завершена в хорошу функцію:

const filterInPlace = (array, predicate) => {
    let end = 0;

    for (let i = 0; i < array.length; i++) {
        const obj = array[i];

        if (predicate(obj)) {
            array[end++] = obj;
        }
    }

    array.length = end;
};

const toDelete = new Set(['abc', 'efg']);

const arrayOfObjects = [{id: 'abc', name: 'oh'},
                        {id: 'efg', name: 'em'},
                        {id: 'hij', name: 'ge'}];

filterInPlace(arrayOfObjects, obj => !toDelete.has(obj.id));
console.log(arrayOfObjects);

Якщо вам не потрібно робити це на місці, це Array#filter:

const toDelete = new Set(['abc', 'efg']);
const newArray = arrayOfObjects.filter(obj => !toDelete.has(obj.id));

Ви можете видалити предмет за одним із його властивостей, не використовуючи сторонніх вкладишів, подібних до цього:

var removeIndex = array.map(item => item.id)
                       .indexOf("abc");

~removeIndex && array.splice(removeIndex, 1);

З подачею / підкресленням:

Якщо ви хочете змінити існуючий масив, тоді нам доведеться використовувати сплайс . Ось трохи кращий / читабельний спосіб за допомогою findWhere підкреслення / подання:

var items= [{id:'abc',name:'oh'}, // delete me
                  {id:'efg',name:'em'},
                  {id:'hij',name:'ge'}];

items.splice(_.indexOf(items, _.findWhere(items, { id : "abc"})), 1);

З ES5 або вище

( без подання / підкреслення )

З ES5 далі у нас є findIndexметод масиву, тому його легко без подання / підкреслення

items.splice(items.findIndex(function(i){
    return i.id === "abc";
}), 1);

(ES5 підтримується майже у всіх браузерах morden)

Про FindIndex та його сумісність із браузером

findIndex працює для сучасних браузерів:

var myArr = [{id:'a'},{id:'myid'},{id:'c'}];
var index = arr.findIndex(function(o){
     return o.id === 'myid';
})
if (index !== -1) myArr.splice(index, 1);

Для видалення об'єкта за допомогою його id в заданому масиві;

const hero = [{'id' : 1, 'name' : 'hero1'}, {'id': 2, 'name' : 'hero2'}];
//remove hero1
const updatedHero = hero.filter(item => item.id !== 1);

Якщо ви просто хочете видалити його з існуючого масиву, а не створити новий, спробуйте:

var items = [{Id: 1},{Id: 2},{Id: 3}];
items.splice(_.indexOf(items, _.find(items, function (item) { return item.Id === 2; })), 1);

Цикл оберніть зворотним шляхом, декрементуючи, iщоб уникнути проблеми:

for (var i = arrayOfObjects.length - 1; i >= 0; i--) {
    var obj = arrayOfObjects[i];

    if (listToDelete.indexOf(obj.id) !== -1) {
        arrayOfObjects.splice(i, 1);
    }
}

Або скористайтеся filter:

var newArray = arrayOfObjects.filter(function(obj) {
    return listToDelete.indexOf(obj.id) === -1;
});

Перевірте це за допомогою встановлення та фільтра ES6.

  let result = arrayOfObjects.filter( el => (-1 == listToDelete.indexOf(el.id)) );
  console.log(result);

Ось JsFiddle: https://jsfiddle.net/jsq0a0p1/1/

Тільки рідний JavaScript, будь ласка.

В якості альтернативи, більш "функціонального" рішення, що працює над ECMAScript 5, ви можете використовувати:

var listToDelete = ['abc', 'efg'];
var arrayOfObjects = [{id:'abc',name:'oh'}, // delete me
                      {id:'efg',name:'em'}, // delete me
                      {id:'hij',name:'ge'}]; // all that should remain

arrayOfObjects.reduceRight(function(acc, obj, idx) {
    if (listToDelete.indexOf(obj.id) > -1)
        arrayOfObjects.splice(idx,1);
}, 0); // initial value set to avoid issues with the first item and
       // when the array is empty.

console.log(arrayOfObjects);
[ { id: 'hij', name: 'ge' } ]

Відповідно до визначення "Array.prototype.reduceRight" у ECMA-262 :

ReduRight безпосередньо не мутує об'єкт, на який він викликається, але об'єкт може бути мутований викликами до callbackfn .

Отже, це дійсне використання reduceRight.

var arrayOfObjects = [{id:'abc',name:'oh'}, // delete me
                      {id:'efg',name:'em'}, // delete me
                      {id:'hij',name:'ge'}] // all that should remain

відповідно до вашої відповіді буде така. при натисканні якогось конкретного об'єкта надішліть індекс у параметрі для функції delete me. Цей простий код буде працювати як шарм.

function deleteme(i){
    if (i > -1) {
      arrayOfObjects.splice(i, 1);
    }
}

з фільтром & indexOf

withLodash = _.filter(arrayOfObjects, (obj) => (listToDelete.indexOf(obj.id) === -1));
withoutLodash = arrayOfObjects.filter(obj => listToDelete.indexOf(obj.id) === -1);

з фільтром & включає

withLodash = _.filter(arrayOfObjects, (obj) => (!listToDelete.includes(obj.id)))
withoutLodash = arrayOfObjects.filter(obj => !listToDelete.includes(obj.id));

Якщо вам подобаються короткі та самостійно описові параметри, або якщо ви не хочете використовувати spliceта переходити з прямим фільтром вперед, або якщо ви просто людина SQL, як я:

function removeFromArrayOfHash(p_array_of_hash, p_key, p_value_to_remove){
    return p_array_of_hash.filter((l_cur_row) => {return l_cur_row[p_key] != p_value_to_remove});
}

І вибіркове використання:

l_test_arr = 
[
    {
         post_id: 1,
        post_content: "Hey I am the first hash with id 1"
    },
    {
        post_id: 2,
        post_content: "This is item 2"
    },
    {
        post_id: 1,
        post_content: "And I am the second hash with id 1"
    },
    {
        post_id: 3,
        post_content: "This is item 3"
    },
 ];



 l_test_arr = removeFromArrayOfHash(l_test_arr, "post_id", 2); // gives both of the post_id 1 hashes and the post_id 3
 l_test_arr = removeFromArrayOfHash(l_test_arr, "post_id", 1); // gives only post_id 3 (since 1 was removed in previous line)

Можна використовувати filter. Цей метод завжди повертає елемент, якщо умова істинна. Отже, якщо ви хочете видалити за допомогою id, ви повинні зберегти весь елемент, який не відповідає заданому ідентифікатору. Ось приклад:

arrayOfObjects = arrayOfObjects.filter (obj => obj.id! = idToRemove)