javascript - How to find the key of a value in a nested object recursively - Stack Overflow

admin管理员组

文章数量:1401484

I want to find the key of a value in a Javascript nested object with recursion.

Here is my attempt at the function. Are there more elegant ways to implement this?

const foo = { data: { data2: { data3: 'worked' }, data21: 'rand' }, data01: 'rand01' }

function findKey(obj, target) {
  let result = null;
  if (_.isEmpty(obj) || !_.isObject(obj)){
    return null;
  }
  if (!_.isArray(obj) && Object.keys(obj).length > 0) {
    for(let i=0; i < Object.keys(obj).length; i++){
      let key = Object.keys(obj)[i];
      let val = obj[key];
      if (val === target) {
        return key;
      }else{
        result = findKey(val, target);
      }
      if (result) {break}
    }
  }
  return result;
}
console.log(findKey(foo, 'worked'))

<script src="//cdnjs.cloudflare/ajax/libs/lodash.js/4.17.15/lodash.min.js"></script>

I want to find the key of a value in a Javascript nested object with recursion.

Here is my attempt at the function. Are there more elegant ways to implement this?

const foo = { data: { data2: { data3: 'worked' }, data21: 'rand' }, data01: 'rand01' }

function findKey(obj, target) {
  let result = null;
  if (_.isEmpty(obj) || !_.isObject(obj)){
    return null;
  }
  if (!_.isArray(obj) && Object.keys(obj).length > 0) {
    for(let i=0; i < Object.keys(obj).length; i++){
      let key = Object.keys(obj)[i];
      let val = obj[key];
      if (val === target) {
        return key;
      }else{
        result = findKey(val, target);
      }
      if (result) {break}
    }
  }
  return result;
}
console.log(findKey(foo, 'worked'))

<script src="//cdnjs.cloudflare./ajax/libs/lodash.js/4.17.15/lodash.min.js"></script>

For instance is there a way to avoid having to check the value of result to then break? I feel like result should be able to bubble down the call stack until it returns at the very first function call without having to break.

• javascript
• arrays
• object
• recursion

Share Improve this question Follow edited Aug 27, 2019 at 15:59 Scott Sauyet 50.8k55 gold badges5757 silver badges110110 bronze badges asked Aug 27, 2019 at 14:06 dazzaondmicdazzaondmic 34555 silver badges1414 bronze badges 5

• What if there are multiple values? – briosheje Commented Aug 27, 2019 at 14:14
• @briosheje I only need the first. – dazzaondmic Commented Aug 27, 2019 at 14:15
• Is the dataset consistent? May we encounter Arrays or have the input which is an array instead? – briosheje Commented Aug 27, 2019 at 14:15
• @briosheje We may encounter arrays but the input will always be an object. – dazzaondmic Commented Aug 27, 2019 at 14:23
• You might want to see this question and its answers for a slightly broader question of finding the entire matching path to a value (e.g. ['data1', 'data2', 'data3'] above, which might be joined into 'data1.data2.data3'): stackoverflow./q/56066101 – Scott Sauyet Commented Aug 27, 2019 at 18:21

Add a ment  | 

6 Answers 6

Sorted by: Reset to default 3

This was recently brought back up, and one useful technique was not mentioned, generator functions. Often they simplify recursive traversals that need to stop early. Here we break the problem into two functions. One, the generator function nestedEntries gets all the (nested) key-value pairs in the object. The other calls that and returns the first one that matches a target value supplied.

function * nestedEntries (obj) {
  for (let [k, v] of Object .entries (obj)) {
    yield [k, v]
    if (Object (v) === v) {yield * nestedEntries (v)}
  }
}

const findKey = (obj, target) => {
  for (let [k, v] of nestedEntries (obj)) {
    if (v === target) return k
  }
  return null
}

const foo = {data01: 'rand01', data: {data21: 'rand', data2: { data3: 'worked' } }}

console .log (findKey (foo, 'worked'))

After the few questions made above, it looks like the function should:

• Assume the input is always an object.
• Assume it might encounter arrays in its way.
• Assume it must stop after meeting one value (in case multiple value exists).

The provided input code given by the OP does not handle array cases.

Below code is sampled to work with these sample cases:

• Plain nested object structure.
• Object with nested arrays of objects or elements.

Below function accepts a second argument which is a callback to evaluate whether the element met is actually the one we're looking for. In this way, it's easier to handle more plex checks.

The recursive approach is kept and, once the key is met, the function simply return to avoid unnecessary searchs.

const foo = { data: { data2: { data3: 'worked' }, data21: 'rand' }, data01: 'rand01' };
const fooWithArrays = {
  data: {
    data2: {
      data3: 'not here'
    },
    data4: [
      { data5: 'worked' },
      { data6: 'not me' }
    ]
  }
};
const fooWithExpression = {
  data: {
   data2: {
    data3: { id: 15, name: 'find me!' }
   },
   data21: {
    data25: 'not me'
   }
  }
};

const findKeyByValue = (obj, equalsExpression) => {
  // Loop key->value pairs of the input object.
  for (var [key, v] of Object.entries(obj)) {
    // if the value is an array..
    if (Array.isArray(v)) {
      // Loop the array.
      for (let i = 0; i < v.length; i++) {
        // check whether the recursive call returns a result for the nested element.
        let res = findKeyByValue(v[i], equalsExpression);
        // if so, the key was returned. Simply return.
        if (res !== null && res !== undefined) return res;
      }
    }
    // otherwise..
    else {
      // if the value is not null and not undefined.
      if (v !== null && v !== undefined) {
        // if the value is an object (typeof(null) would give object, hence the above if). 
        if (typeof(v) === 'object') {
          // check whether the value searched is an object and the match is met.
          if (equalsExpression(v)) return key;
          // if not, recursively keep searching in the object.
          let res = findKeyByValue(v, equalsExpression);
          // if the key is found, return it.
          if (res !== null && res !== undefined) return res;
        }
        else {
          // finally, value must be a primitive or something similar. Compare.
          let res = equalsExpression(v);
          // if the condition is met, return the key.
          if (res) return key;
          // else.. continue.
        }
      }
      else continue;
    }
  }
}

console.log( findKeyByValue(foo, (found) => found === 'worked') );
console.log( findKeyByValue(fooWithArrays, (found) => found === 'worked') );
console.log( findKeyByValue(fooWithExpression, (found) => found && found.id && found.id === 15) );

You can use Object.entries to iterate all the keys.

Also worth noting, Object.entries also works with Array's, so no special handling required.

const foo = { data: { data2: { data3: 'worked' }, data21: 'rand' }, data01: 'rand01', arr: [{arrtest: "arr"},'xyz']}

function findKey(obj, target) {
  const fnd = obj => {
    for (const [k, v] of Object.entries(obj)) {
      if (v === target) return k;
      if (typeof v === 'object') {
        const f = fnd(v);
        if (f) return f;
      }
    }
  }
  return fnd(obj);
}
console.log(findKey(foo, 'worked'))
console.log(findKey(foo, 'arr'))
console.log(findKey(foo, 'xyz'))

If obj is exactly a plain object with subobjects without arrays, this does the trick.

function findKey(obj, target) {
  for (let key in obj) {
    const val = obj[key];
    if (val === target) {
      return key;
    }
    if (typeof val === "object" && !Array.isArray(val)) {
      const ret = findKey(val, target);
      if (ret) return ret;
    }
  }
}
const foo = {
  data: { data2: { data3: "worked" }, data21: "rand" },
  data01: "rand01",
};

console.log(findKey(foo, "worked"));
console.log(findKey(foo, "bloop"));

You can try regex, if data is just objects without arrays:

const foo = { data: { data2: { data3: 'worked' }, data21: 'rand' }, data01: 'rand01' }
const out = JSON.stringify(foo).match(/"([^{}]+)":"worked"/)[1];
console.log(out);

For simple data processing tasks like this we use object-scan. It's very powerful once you wrap your head around it and makes things a lot cleaner. Here is how you'd solve your questions

(took the liberty to take the input data from @briosheje answer)

// const objectScan = require('object-scan');

const findKeyByValue = (data, fn) => objectScan(['**'], {
  abort: true,
  rtn: 'property',
  filterFn: ({ value }) => fn(value) === true
})(data);

const foo = { data: { data2: { data3: 'worked' }, data21: 'rand' }, data01: 'rand01' };
const fooWithArrays = { data: { data2: { data3: 'not here' }, data4: [{ data5: 'worked' }, { data6: 'not me' }] } };
const fooWithExpression = { data: { data2: { data3: { id: 15, name: 'find me!' } }, data21: { data25: 'not me' } } };

console.log(findKeyByValue(foo, (found) => found === 'worked'));
// => data3
console.log(findKeyByValue(fooWithArrays, (found) => found === 'worked'));
// => data5
console.log(findKeyByValue(fooWithExpression, (found) => found && found.id && found.id === 15));
// => data3
console.log(findKeyByValue(fooWithExpression, (found) => false));
// => undefined

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

<script src="https://bundle.run/[email protected]"></script>

Disclaimer: I'm the author of object-scan

本文标签： javascriptHow to find the key of a value in a nested object recursivelyStack Overflow