Enlever la clé égale entre deux JSON

Question

J'ai un gros problème. Je veux créer une fonction qui supprime des parties égales entre deux fichiers JSON, avec la sortie de la fonction ayant la même structure, mais sans les parties égales.

Un exemple que j'ai une version JSON d'un arbre DOM et je veux garder que la différence entre les pages (enlever le pied de page nav ...)

Exemple

const a = { 
    id: '1', 
    child: [ 
    { 
    id: '2', 
    child: [ 
     { 
     id: '1' 
     }, 
     { 
     id: '2' 
     } 
    ] 
    }, 
    { 
    id: '3', 
    child: [ 
     { 
     id: '1' 
     }, 
     { 
     id: '5' 
     } 
    ]  
    } 
    ] 
} 

Et

const b = { 
    id: '1', 
    child: [ 
    { 
    id: '2', 
    child: [ 
     { 
     id: '1' 
     }, 
     { 
     id: '4' 
     } 
    ] 
    }, 
    { 
    id: '3', 
    child: [ 
     { 
     id: '1' 
     }, 
     { 
     id: '4' 
     } 
    ]  
    } 
    ] 
} 

Avec une fonction

diff(a, b) 

Ce résultat

{ 
    id: '1', 
    child: [ 
    { 
    id: '2', 
    child: [ 
     { 
     id: '2' 
     } 
    ] 
    }, 
    { 
    id: '3', 
    child: [ 
     { 
     id: '5' 
     } 
    ]  
    } 
    ] 
} 

J'ai créé cette base de la fonction récursive

const diff = (a, b) => { 
    if (Array.isArray(a)) { 

    } 

    if (typeof a === 'object') { 
    // ... 
    extract(a.child, b.child); 
    } 
} 

Comment puis-je faire? Y a-t-il un paquet npm? ou avec le chemin JSON? Je veux créer une fonction qui supprime les 'parties' égales entre deux fichiers JSON avec la sortie de la fonction ayant la même structure, mais sans les 'parties égales'.

Answer 1

Je suppose que vous ne pouvez pas garantir l'ordre des paires id/valeur?

Je suggérerais que vous fusionniez d'abord récursivement chaque couche, puis passiez et supprimiez les doublons.

Edité avec le code de la fonction Recursion

let c = [] // merged structure 
for (var i=0; i<a.length; i++) 
{ 
    for (let j=0; j<b.length; j++) 
    { 
     if (a[i].id === j[i].id) { 
     c[i] = { id: a[i].id, child: a[i].child.concat(b[i].child) } 
     // next, sort the c[i].child, and 
     // loop through c[i].child and recur over any cases where 
     // c[i].child[k].id === c[i].child[k+1].id 
     // at the end, go back up the chain removing any structs where the 
     // id is a duplicate and has no children left 
     } 
    } 
}