nesneleri nesne tarafından diziden kaldır

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

Nesne özelliğini eşleştirerek diziden bir nesneyi nasıl kaldırabilirim?

Sadece yerel JavaScript lütfen.

Eklemeyi kullanırken sorun yaşıyorum çünkü uzunluk her silme işleminde azalıyor. Orignal indeks üzerinde klonlama ve birleştirme kullanma, hala azalan uzunluk problemi ile sonuçlanır.

Sanırım spliceböyle bir şey kullandın mı?

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

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

Hatayı düzeltmek için yapmanız gereken tek şey i, bir dahaki sefere azalmaktır , ve (geri döngü de bir seçenektir):

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

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

Doğrusal zaman silmelerini önlemek için , dizinin üzerinde tutmak istediğiniz dizi öğelerini yazabilirsiniz :

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;

ve modern bir çalışma zamanında doğrusal zaman aramasını önlemek için bir karma kümesini kullanabilirsiniz:

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;

güzel bir işlevle sarılabilir:

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

Yerinde yapmanız gerekmiyorsa, bu Array#filter:

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

Aşağıdaki gibi herhangi bir üçüncü taraf kütüphanesi kullanmadan bir öğeyi özelliklerinden biriyle kaldırabilirsiniz:

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

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

Lodash / alt çizgi ile:

Varolan dizinin kendisini değiştirmek istiyorsanız, splice kullanmamız gerekir . FindWhere alt çizgi / lodash kullanarak biraz daha iyi / okunabilir yolu :

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 veya üstü ile

( lodash / alt çizgi olmadan )

ES5'ten sonra findIndexdizi üzerinde yöntemimiz var , bu yüzden lodash / alt çizgi olmadan kolay

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

(ES5 neredeyse tüm morden tarayıcılarda desteklenir)

FindIndex ve Tarayıcı uyumluluğu hakkında

findIndex modern tarayıcılar için çalışır:

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

Bir nesneyi verilen dizideki kimliğiyle silmek için;

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

Sadece mevcut diziden kaldırmak ve yeni bir dizi oluşturmak istemiyorsanız, şunu deneyin:

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

iSorunu önlemek için azaltarak ters çevirin :

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

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

Veya şunu kullanın filter:

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

Set ve ES6 filtresini kullanarak bunu kontrol edin.

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

İşte JsFiddle: https://jsfiddle.net/jsq0a0p1/1/

Sadece yerel JavaScript lütfen.

ECMAScript 5 üzerinde çalışan alternatif, daha "işlevsel" bir çözüm olarak şunları kullanabilirsiniz:

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

ECMA-262'deki 'Array.prototype.reduceRight' tanımına göre :

reduceRight, çağrıldığı nesneyi doğrudan değiştirmez, ancak nesne callbackfn çağrılarıyla mutasyona uğrayabilir .

Yani bu geçerli bir kullanımdır reduceRight.

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

cevabınıza göre böyle olacak. Belirli bir nesneyi tıklattığınızda, beni sil işlevi için parametrede dizini gönderin. Bu basit kod cazibe gibi çalışacaktır.

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

filtre ve index ile

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

filtre ve içerir

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

Kısa ve kendini tanımlayan parametreleri seviyorsanız veya splicedüz bir filtreyle kullanmak ve gitmek istemiyorsanız veya sadece benim gibi bir SQL kişisiyseniz:

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

Ve örnek bir kullanım:

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)

Kullanabilirsiniz filter. Koşul doğruysa bu yöntem her zaman öğeyi döndürür. Bu nedenle, kimliğe göre kaldırmak istiyorsanız, verilen kimliğe uymayan tüm öğeleri saklamanız gerekir. İşte bir örnek:

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