Compare JSON Keys to get missing elements

Question

I want to compare to Nested Objects and create a new Object with all the missing fields. I have a main JSON respone in a Javascript Object:

var MainFile = {
     "id": 0,
     "name": 'test',
     "info": {
           "data_11":0,
           "data_12":0,
           "data_13":{
                "data_131":0,
                "data_132":0,
                "data_133":0,
           },
     },
     "info2": {
          "data_21":0,
          "data_22":0,
          "data_23":0,
          }
     }

And now I have x amount of objects that I have to compare against the main and check that object has all the same keys.

var obj2 = {
     "id": 0,
     "info": {
         "data_11":0,
         "data_13":{
             "data_131":0,
             "data_133":0,
         },
     },
     "info2": {
         "data_22":0,
         "data_23":0,
         }  
     }
 }

So seeing both objects we can see the differences. I've tried recursive functions to check with Object.hasProperty, but I never get the result I'm looking for. that would be an object that would look like the following:

result = {
     "id": true,
     "name": false,
     "info": {
         "data_11":true,
         "data_12":false,
         "data_13":{
             "data_131":false,
             "data_132":true,
             "data_133":false,
         },
     },
     "info2": {
          "data_21":true,
          "data_22":false,
          "data_23":false,
          }
     }

Has anyone tried anything like this? I've looked everywhere, but everyone compares the value of the key, not if the actual key is missing in the nested array.

Any help would be appreciated

JSON is a *textual notation* for data exchange. [(More here.)](http://stackoverflow.com/a/2904181/157247) If you're dealing with JavaScript source code, and not dealing with a *string*, you're not dealing with JSON. — T.J. Crowder, Mar 29 '22 at 10:46
Why do you have `name = true` in the result? It does not exist in the object being checked. — Salman A, Mar 29 '22 at 10:50
So this is only to report whether fields are missing, not whether they've changed value or even data type? — Scott Sauyet, Mar 29 '22 at 13:09

score 0 · Answer 1 · answered Mar 29 '22 at 13:59

One advantage of keeping around a collection of useful utility functions is that we can combine them quickly to create new functionality. For me, this function is as simple as this:

const diffs = (o1, o2) => 
  hydrate (getPaths (o1) .map (p => [p, hasPath (p) (o2)]))

We first call getPaths (o1), which yields

[
  ["id"],
  ["name"],
  ["info", "data_11"],
  ["info", "data_12"],
  ["info", "data_13", "data_131"],
  ["info", "data_13", "data_132"],
  ["info", "data_13", "data_133"],
  ["info2", "data_21"],
  ["info2", "data_22"],
  ["info2", "data_23"]
]

Then we map these into path entry arrays, using hasPath against our test object, which yields:

[
  [["id"], true], 
  [["name"], false],
  [["info", "data_11"], true],
  [["info", "data_12"], false],
  [["info", "data_13", "data_131"], true],
  [["info", "data_13", "data_132"], false],
  [["info", "data_13", "data_133"], true],
  [["info2", "data_21"], false],
  [["info2", "data_22"], true],
  [["info2", "data_23"], true]
]

This is very similar to the format used by Object .fromEntries, except that the keys are arrays of values rather than single strings. (Those values could be strings for object keys or integers for array indices.) To turn this back into an object, we use hydrate, which in turn depends upon setPath. Again hydrate tis a generalization of Object .fromEntries, and setPath is a recursive version of setting a value.

Put together it looks like this:

// utility functions
const getPaths = (obj) =>
  Object (obj) === obj
    ? Object .entries (obj) .flatMap (
        ([k, v]) => getPaths (v) .map (p => [Array .isArray (obj) ? Number(k) : k, ... p])
      )
    : [[]]

const setPath = ([p, ...ps]) => (v) => (o) =>
  p == undefined ? v : Object .assign (
    Array .isArray (o) || Number .isInteger (p) ? [] : {},
    {...o, [p]: setPath (ps) (v) ((o || {}) [p])}
  )

const hydrate = (xs) =>
  xs .reduce ((a, [p, v]) => setPath (p) (v) (a), {})

const hasPath = ([p, ...ps]) => (obj) => 
  p == undefined ? true : p in obj ? (ps .length > 0 ?  hasPath (ps) (obj [p]) : true) : false

// main function
const diffs = (o1, o2) => 
  hydrate (getPaths (o1) .map (p => [p, hasPath (p) (o2)]))

// sample data
const MainFile = {id: 0, name: "test", info: {data_11: 0, data_12: 0, data_13: {data_131: 0, data_132: 0, data_133: 0}}, info2: {data_21: 0, data_22: 0, data_23: 0}}
const obj2 = {id: 0, info: {data_11: 0, data_13: {data_131: 0, data_133: 0}}, info2: {data_22: 0, data_23: 0}};

// demo
console .log (diffs (MainFile, obj2))

.as-console-wrapper {max-height: 100% !important; top: 0}

The functions that this is built upon are all generally useful for many problems, and I simply keep them in my back pocket. You may note that this also handles arrays; that just comes along with those functions

diffs ({foo: ['a', 'b', 'c']}, {foo: ['a', 'b']}) 
//=> {"foo": [true, true, false]}

I also want to note that if you're looking for a more complete diff function, an old answer by user Mulan is a great read.

Compare JSON Keys to get missing elements

1 Answers1