如何递归查找嵌套对象中值的键

Question

我想在一个带有递归的Javascript嵌套对象中找到一个值的键。

下面是我对函数的尝试。有没有更优雅的方法来实现这一点？

null

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.com/ajax/libs/lodash.js/4.17.15/lodash.min.js"></script>

null

例如，有没有一种方法可以避免检查result的值然后中断？我觉得result应该能够在调用堆栈中冒泡，直到它在第一次函数调用时返回，而不必中断。

Answer 1

在上面提出的几个问题之后，该函数看起来应该：

• 假设输入始终是对象。
• 假设它可能会以它的方式遇到数组。
• 假设在满足一个值后必须停止（如果存在多个值）。

OP提供的输入代码不处理数组情况。

对以下代码进行了采样，以便使用这些示例案例：

• 纯嵌套对象结构。
• 对象或元素的嵌套数组。

Below函数接受第二个参数，这是一个回调，用于评估met元素是否是我们要查找的元素。这样，处理更复杂的检查就更容易了。

保留递归方法，一旦满足键，函数只需return，以避免不必要的搜索。

null

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) );