Löschen nicht übereinstimmender Objekte in verschachtelten Array

Question

Ich habe Probleme, die Spleißmethode in einem verschachtelten Array in einer allgemeinen Weise zu verwenden. Also was ich will ist, um Objekte in "BigArray" s "NestedArray" s zu löschen, wenn "FilterArray" keine Referenz für das Objekt haben.

Ich habe ein Beispiel gemacht, was ich tun möchte. Wenn Sie eine Lösung bekommen, wie ich es in nativem Javascript verbessern kann oder mit Lodash, geben Sie mir gerne Input. Ich bin wirklich festgefahren.

Erwartetes Ergebnis sollte sein:

sort.unsortedArray = { "bigArray" : [ 
    {"id": 1, "text" : "This should be visible when done", 
    "nestedArray": [ 
     { "id": 2, "nestedText": "Sort me out!" } 
    ] 
    }, 
    { "id": 2, "text" : "This should be visible when done", 
    "nestedArray": [ 
    { "id": 2, "nestedText": "This one should be visible in the coming array" } 
    ] 
    }]} 

Heres ein codepen dafür.

var sort = this; 
var init = function(){ 
    sort.outObjects(); 
}; 
sort.filterArray = { "filter" : [ 
    { "id": 3, "groupId": 1 }, 
    { "id": 2, "groupId": 2 }]}; 

sort.unsortedArray = { "bigArray" : [ 
    {"id": 1, "text" : "This should be visible when done", 
    "nestedArray": [ 
     { "id": 1, "nestedText":"Sort this one out!" }, 
     { "id": 2, "nestedText": "Sort me out!" }, 
     { "id": 3, "nestedText": "This one should be visible in the coming array"}]}, 

    { "id": 2, "text" : "This should be visible when done", 
    "nestedArray": [ 
     { "id": 1, "nestedText": "Sort me out!" }, 
     { "id": 2, "nestedText": "This one should be visible in the coming array" }, 
     {"id": 3, "nestedText": "Sort this one out!" }]} 
]}, 

sort.outObjects = function(){ 

    //Check that we got the objects in same scope 
    if(sort.filterArray && sort.unsortedArray){ 

    //Loop through "bigArray" object 
    for(var i = 0; i< sort.unsortedArray.length; i++){ 

    console.log("sort.unsortedArray.length : ", sort.unsortedArray.length); 

     //Loop through each "nestedArray":s objects 
     for(var j = 0; j< sort.unsortedArray[i].nestedArray.length; j++){ 
     console.log("sort.unsortedArray[i].nestedArray.length : ", sort.unsortedArray[i].nestedArray.length); 

     //Loop through filterArray object and compare each object in nested array, if they dont match, delete them. 

     for(var k = 0; k< sort.filterArray.length; k++){ 
     console.log("sort.filterArray.length : ", sort.filterArray.length); 

     if(sort.filterArray[k].id != sort.unsortedArray[i].nestedArray[j].id){ 

     //Delete unmatching object from unsortedArray 
      sort.unsortedArray[i].nestedArray.splice(j,1); 

     console.log("sort.unsortedArray after splice : ", sort.unsortedArray); 
     } 
     } 
    } 
    } 
    } 
    else{ 
    console.log("Missing connection to object",sort.filterArray, sort.unsortedArray); 
    } 
} 

init(); 

Answer 1

Sie könnten ein Objekt für einen schnelleren Zugriff generieren und für die endgültige Filterung testen.

Nach dem Generieren können Sie über die Daten iterieren, prüfen, ob eine Änderung erforderlich ist, und Filter anwenden.

Edit: Vorschlag für mehr als eine ID zu halten.

var filterArray = { "filter": [{ "id": 3, "groupId": 1 }, { "id": 2, "groupId": 2 }] }, 
 
    unsortedArray = { "bigArray": [{ "id": 1, "text": "This should be visible when done", "nestedArray": [{ "id": 1, "nestedText": "Sort this one out!" }, { "id": 2, "nestedText": "Sort me out!" }, { "id": 3, "nestedText": "This one should be visible in the coming array" }] }, { "id": 2, "text": "This should be visible when done", "nestedArray": [{ "id": 1, "nestedText": "Sort me out!" }, { "id": 2, "nestedText": "This one should be visible in the coming array" }, { "id": 3, "nestedText": "Sort this one out!" }] }] }, 
 
    filterObject = Object.create(null); 
 

 
filterArray.filter.forEach(function (a) { 
 
    filterObject[a.groupId] = filterObject[a.groupId] || Object.create(null); 
 
    filterObject[a.groupId][a.id] = true; 
 
}); 
 

 
unsortedArray.bigArray.forEach(function (a) { 
 
    if (a.id in filterObject) { 
 
     a.nestedArray = a.nestedArray.filter(function (b) { 
 
      return filterObject[a.id][b.id]; 
 
     }); 
 
    } 
 
}); 
 
console.log(filterObject); 
 
console.log(unsortedArray);

Answer 2

Das wäre meine Lösung sein;

var fa = { "filter" : [{ "id": 3, "groupId": 1 },{ "id": 2, "groupId": 2 }]}, 
 
    usa = { "bigArray" : [{"id": 1, "text" : "This should be visible when done", "nestedArray": [{ "id": 1, "nestedText":"Sort this one out!" },{ "id": 2, "nestedText": "Sort me out!" },{ "id": 3, "nestedText": "This one should be visible in the coming array"}]},{ "id": 2, "text" : "This should be visible when done","nestedArray": [{ "id": 1, "nestedText": "Sort me out!" },{ "id": 2, "nestedText": "This one should be visible in the coming array" },{"id": 3, "nestedText": "Sort this one out!" }]}]}, 
 
    sa = fa.filter.reduce((p,c) => { var f = p.find(f => f.id == c.groupId); 
 
            f && (f.nestedArray = f.nestedArray.reduce((n,o) => o.id == c.id ? n.concat(o) : n,[])); 
 
    \t        return p } 
 
            ,usa.bigArray); 
 
console.log(sa);