Returning array of nested keys recursively javascript

Question

Trying to create a function that returns an array of the keys of an object, including of objects nested within. My code looks like this:

function keyCount(obj, arr) {
  if (arr == undefined){
    arr = []
  }
  let keys = Object.keys(obj);
  let length = keys.length;
  for (i = 0; i <= length; i++){
    if (Object.keys(obj)[i] !== undefined){
      arr.push(Object.keys(obj)[i]);
    }
  }
  for (i = 0; i <= length; i++){
    if (typeof(obj[Object.keys(obj)[i]]) === "object" && obj[Object.keys(obj)[i]] !== null && Object.keys(obj)[i] !== undefined){
      let nestedobj = obj[Object.keys(obj)[i]];
      keyCount(nestedobj,arr)
    }
  }
  return (arr);
}

This returns the first level keys and the keys of one nested object, but exits the function after the first recursive call. Is there a way around this or a better way to format the code? Thanks in advance!

Edited: Data expectations:

let obj1 = {
1:"a",
2:{
  3: "b",
  4: "c"},
5:{
  6:"d",
  7: "e",
  8: {
    9: "f",
    10: "g"},
    11:{
      12:"h",
      13: "i"
      }
    }
  };

Should return:

[1,2,5,3,4,6,7,8,9,10,11,12,13]

But only returns:

[1,2,5,3,4]

Possible duplicate of [How to get all keys with values from nested objects](https://stackoverflow.com/questions/47062922/how-to-get-all-keys-with-values-from-nested-objects) — Durga, Mar 08 '18 at 12:38
@Durga Here he asks for the keys only, that question has other meaning in question subject. — Basel Issmail, Mar 08 '18 at 12:40
You really should not repeatedly call `Object.keys(obj)`. That's what you created the `let keys` variable for! — Bergi, Mar 08 '18 at 13:03
You need to use `i < length` instead of `i <= length`. Then you also won't have to check whether a key is `undefined`... — Bergi, Mar 08 '18 at 13:05

score 1 · Answer 1 · answered Mar 08 '18 at 13:04

You could take the keys and check if the value is an object, then take this keys as well.

function getKeys(object) {
    return Object
        .keys(object)
        .reduce((r, k) => r.concat(k, object[k] && typeof object[k] === 'object' ? getKeys(object[k]) : []), []);
}


var object = { 1: "a", 2: { 3: "b", 4: "c" }, 5: { 6: "d", 7: "e", 8: { 9: "f", 10: "g" }, 11: { 12: "h", 13: "i" } } };

console.log(getKeys(object));

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

@georg, right it is guarded by the check `object[k]` before. — Nina Scholz, Mar 08 '18 at 13:18

score 0 · Accepted Answer · answered Mar 08 '18 at 13:13

There are various problems with your code. The most important is that i is implicitly global, which causes your recursive call to alter the loop condition. You're lucky that you didn't get an infinite loop…

function keyCount(obj, arr) {
  "use strict";
//^^^^^^^^^^^^^ prevent mistakes with forgotten declarations
  if (arr == undefined){
    arr = []
  }
  const keys = Object.keys(obj);
//^^^^^ prefer const over let when you don't assign
  const length = keys.length;
  for (let i = 0; i < length; i++) {
//                 ^^^ don't use <=
//     ^^^ i needs to be a local variable!
    // if (keys[i] !== undefined)
//  ^^^ no longer necessary when having fixed the loop
      arr.push(keys[i]);
//             ^^^^ don't call Object.keys again
  }
  for (let i = 0; i < length; i++) {
//     ^^^          ^ same as above
    const nestedobj = obj[keys[i]]; // move this up here
//                        ^^^^ same as above
    if (typeof nestedobj === "object" && nestedobj !== null  ) {
//            ^         ^ typeof is not a function          ^ same as above
      keyCount(nestedobj, arr);
    }
  }
  return arr;
}

Thank you, this is enormously helpful ! – bx ded Mar 09 '18 at 13:20 — bx ded, Mar 09 '18 at 13:20

score 0 · Answer 3 · answered Mar 08 '18 at 13:14

let obj1 = {
1:"a",
2:{
  3: "b",
  4: "c"},
5:{
  6:"d",
  7: "e",
  8: {
    9: "f",
    10: "g"},
    11:{
      12:"h",
      13: "i"
      }
    }
  };

var keyArray = [];

function getKeys(obj){
  // get the keys from the current level
  var keys = Object.keys( obj );
  // iterate through each key, add it to our keyArray[]
  for( var i=0, x=keys.length; i<x; i++ ){
    keyArray.push( keys[i] );
    // if there is another array/object (instead of a
    // value) send that section of the obj back into
    // the function
    if( obj[keys[i]].constructor === Object ){
      getKeys( obj[keys[i]] );
    }
  }
}

getKeys(obj1);

//Should return:
//console.log( 'expected', [1,2,5,3,4,6,7,8,9,10,11,12,13] );
console.log( 'result: ', keyArray.join(',') );

@Leafyshark if I understand your comment: Starting with Object.keys(obj1) and then looping over those results will only get the code down two levels (top level and the next one scanned). Using a recursive loop, the code can dig as deep as the object has nested data. — Doug, Mar 08 '18 at 13:25

score 0 · Answer 4 · answered Mar 08 '18 at 13:24

Since the answers posted so far don't handle circular objects, here's the one that does:

function getKeys(obj) {
    let seen = new WeakSet(),
        keys = new Set(),
        queue = [obj];

    while (queue.length) {
        let obj = queue.shift();
        
        if (!obj || typeof obj !== 'object' || seen.has(obj))
            continue;
        
        seen.add(obj);
        
        for (let [k, v] of Object.entries(obj)) {
            keys.add(k);
            queue.push(v);
        }
    }

    return [...keys];
}

//

weirdo = {a: 1, b: 2, c: 3}
weirdo.self = weirdo;
console.log(getKeys(weirdo))

And it's not recursive, so it handles more than 10,000 levels of nesting (which is a quite common situation in today's webdev ;)

Returning array of nested keys recursively javascript

4 Answers4