Recursively find keys on an object

Question

I have a javascript object structured like this;

brand: {
  group: {
    subGroup: {
       items: []
    },
    otherSub: {
       items: []
    }
  }
}

Given an array of keys ['brand', 'group', 'newGroup', 'newSubGroup'] I want to split the keys into found and missing keys. So for the structure above I should get back;

present = ['brand', 'group']
missing = ['newGroup', 'newSubGroup']

I'm using ES6 and have lodash available, but struggling to find a clean way to produce this.

This is not to just check existence, it's recursively find the keys and return those present and the remaining ones.

Not a duplicate of that. I'm trying to find the cleanest way to work recursively through the object and split the array into the keys found and those that are not present. — james2m, Jul 19 '17 at 17:35
Maybe overkill but have you seen [this object diffing package](https://www.npmjs.com/package/deep-diff)? I've used it before and I've found it useful. — alexanderbird, Jul 19 '17 at 17:42
Also if you're struggling to find a clean way to do it, could you include the "not clean" way that you've been able to do it? — alexanderbird, Jul 19 '17 at 17:44
I've not selected an answer because I ended up going in a different direction which made this unnecessary — james2m, Aug 03 '17 at 06:19

Arthur · Answer 1 · 2017-07-19T17:55:05.170

You can use this function made for you ;)

var getAttrs = function(obj) {
  return [].concat.apply([], Object.keys(obj).map(function (key) { 
    var results = [key]
    if (typeof obj[key] === 'object') {
      Array.prototype.push.apply(results, getAttrs(obj[key]))
    }
    return results
  }))
}

It return the list of properties and children properties.

getAttrs({brand: {
  group: {
    subGroup: {
       items: []
    },
    otherSub: {
       items: []
    }
  }
}})

> ["brand", "group", "subGroup", "items", "otherSub", "items"]

And you can use it like so:

var lookingFor = ['brand', 'group', 'newGroup', 'newSubGroup']
var existings = getAttrs(obj)

var missings = []
var presents = []

lookingFor.forEach(attr => {
  if (existings.indexOf(attr) === -1) {
    missings.push(attr)
  } else { 
    presents.push(attr)
  }
})

score 2 · Answer 2 · answered Jul 19 '17 at 17:51

2

Here's a pretty sketchy way that works.

const find = (keys, obj) => {
  const string = JSON.stringify(obj);
  return keys.reduce(({ present, missing }, key) => {
    const match = string.match(new RegExp(`"${key}":`));
    if (match) {
      present.push(key);
    } else {
      missing.push(key);
    }
    return { present, missing };
  }, { present: [], missing: [] });
}

answered Jul 19 '17 at 17:51

pabombs

1,380
2
14
15

I quite like the terseness of this, but the JSON.stringify disturbs me a little. I guess that's what you meant by sketchy. – james2m Aug 03 '17 at 06:06

Lucky Soni · Answer 3 · 2017-07-20T12:58:09.877

    var toFind = ['brand', 'group', 'newGroup', 'newSubGroup'],
        found = [];

    var o = {
        brand: {
            group: {
                subGroup: {
                    items: []
                },
                otherSub: {
                    items: []
                }
            }
        }
    }

    //called with every property and its value
    function process(key,value) {
        var i = toFind.indexOf(key);
        if(i !== -1){
          found.push(key);
          toFind.splice(i, 1);
        }
    }
    
    function traverse(o,func) {
        if(!toFind.length) return;
        for (var i in o) {
            func.apply(this,[i,o[i]]);  
            if (o[i] !== null && typeof(o[i])=="object") {
                //going one step down in the object tree!!
                traverse(o[i],func);
            }
        }
    }
    
    traverse(o,process);

    console.log(found); // present
    console.log(toFind); // absent

Traverse method taken from https://stackoverflow.com/a/722732/1335165

score 0 · Answer 4 · answered Jul 19 '17 at 18:01

I wrote a function to recursively get unique keys from a nested object, then filtered the array of all the keys you mentioned checking which were present in the result of my function.

var thisObject = {
 brand: {
    group: {
      subGroup: {
          items: []
      },
      otherSub: {
          items: []
      }
        }
   }
};

var arr_full =  ['brand', 'group', 'newGroup', 'newSubGroup'] ;

var key_array = [];

function addToKeyArray( key_array, object ){
 
    for( var key in object ){
    
     // only get unique keys
     if( key_array.indexOf( key ) === -1 ){
         key_array.push( key );
        }
    
     // concat the result of calling this function recurrsively on object[key]
     key_array.concat( addToKeyArray( key_array, object[key] ) ); 
    }
    
    return key_array;
}


var test = addToKeyArray( [], thisObject );

var missing = arr_full.filter( function( el ) {
  return test.indexOf( el ) < 0;
});

console.log( test );
console.log( missing )

Nenad Vracar · Answer 5 · 2017-07-19T18:21:50.437

You can create recursive function using for...in loop inside another function and return object as result..

var obj = {"brand":{"group":{"subGroup":{"items":[]},"otherSub":{"items":[]}}}}
var keys =  ['brand', 'group', 'newGroup', 'newSubGroup'] ;

function findKeys(data, keys) {
  keys = keys.slice();
  
  function findPresent(data, keys) {
    var result = []
    
    for(var i in data) {
      if(typeof data[i] == 'object') result.push(...findPresent(data[i], keys))
      var index = keys.indexOf(i);
      if(index != -1) result.push(...keys.splice(index, 1))
    }
    
    return result
  }
  
  return {present: findPresent(data, keys), missing: keys}
}

console.log(findKeys(obj, keys))

Rick · Answer 6 · 2017-07-19T18:33:22.420

To keep things clean and readable you can use "for in", inside a nested function for your recursion.

function recur(obj) {
  let preMiss = {
    present: [],
    missing: []
  }
  let root = traverse => {
    for (let key in traverse) {
      if (Array.isArray(traverse[key].items)) {
        preMiss.missing.push(key);
      }
      if (typeof traverse[key] === 'object' && !Array.isArray(traverse[key].items)) {
        preMiss.present.push(key);
        root(traverse[key])
      }
    }
  }
  root(obj);
  return preMiss;
}

const object = {
  brand: {
    group: {
      subGroup: {
        items: []
      },
      otherSub: {
        items: []
      }
    }
  }
}


console.log(Object.entries(recur(object)));

score 0 · Answer 7 · answered Jun 10 '18 at 18:02

Even though this question is a bit older, I want to present a rather short solution to the problem.

const recursivelyGetKeys = obj => Object.keys(obj).map(key => typeof obj[key] === 'object' 
? [...recursivelyGetKeys(obj[key]), key] : [key]).reduce((p, c) => [...p, ...c], [])

This function will return all keys in the object, so a call to the array arr with

const arr = {
  brand: {
    group: {
       subGroup: {
          items: []
       },
       otherSub: {
          items: []
       }
     }
   }
 }

will output:

const keys = recursivelyGetKeys(arr) // = ["items", "subGroup", "items", "otherSub", "group", "brand"]

Now to find the intersection set of this and find = ['brand', 'group', 'newGroup', 'newSubGroup'], do:

const found = keys.filter(key => find.some(val === key))
const missing = keys.filter(key => find.every(val !== key))

Recursively find keys on an object

7 Answers7