获取深层嵌套对象结构中的父、祖父和键答案

【问题标题】：Get parent, grandparent and key in the deep nested object structure获取深层嵌套对象结构中的父、祖父和键
【发布时间】：2021-10-22 00:20:26
【问题描述】：

我在 javascript 对象中有一个深度嵌套的结构，其中没有任何数组。

var data = {
  bar: 'a',
  child: {
    b: 'b',
    grand: {
      greatgrand: {
        c: 'c'
      }
    }
  }
};

let arr = [];

const findParentGrandparent = (obj, target) => {
  Object.entries(obj).forEach(child => {
    if (typeof child[1] === 'object') {
      findParentGrandparent(child[1]);
    }
  });
};
findParentGrandparent(data, 'c');

当我使用目标调用函数时，我想获取目标键本身、父项和祖父项。例如，如果目标是 'c'，arr 应该变成

['c', 'greatgrand', 'grand', 'child'];

如果目标是'greatgrand'，它应该变成

['greatgrand', 'grand', 'child'];

谢谢

【问题讨论】：

标签： javascript arrays object recursion nested

【解决方案1】：

我是用你的递归模式做的，你也可以改变它处理错误的方式，如果没有结果我就扔在这里。

var data = {
  bar: 'a',
  child: {
    b: 'b',
    grand: {
      greatgrand: {
        c: 'c'
      }
    }
  }
};

let arr = [];

const findParentGrandparent = (obj, target) => {
  for (const child of Object.entries(obj)) {
    if (typeof child[1] === 'object' && child[0] !== target) {
      const result = findParentGrandparent(child[1], target);
      return [...result, child[0]];
    } else if (child[0] === target) {
      return [child[0]];
    }
  };
  throw new Error("not found"); // If it goes there the object is not found, you can throw or return a specific flag, as you wish.
};

console.log(findParentGrandparent(data, 'c'));

【讨论】：

如果对您有用，您可以投票/接受答案，如果您对此代码有任何疑问，请随时询问

【解决方案2】：

var data = {
    bar: 'a',
    child: {
        b: 'b',
        grand: {
            greatgrand: {
                c: 'c'
            }
        }
    }
};

/**
* @param validate {boolean} = true - Pass true if need to check for existance of `target`
*/
const findParentGrandparent = (obj, target, validate = true) => {
    let result = [];
    for (let [key, value] of Object.entries(obj)) {
        if (key === target) {
            result.push(key);
            break;
        }
        if (value.toString() === '[object Object]') {
            result.push(key);
            result = result.concat(findParentGrandparent(value, target, false))
        }
    }

    if (validate && !result.includes(target)) {
        return 'Not found';
    }

    return result;
};

let resultC = findParentGrandparent(data, 'c').reverse();
let resultGreatgrand = findParentGrandparent(data, 'greatgrand').reverse();


console.log('Result for "c":', resultC);
console.log('Result for "greatgrand":', resultGreatgrand);

【讨论】：

我有点挑剔，但是如果你发送“toto”例如你会得到意想不到的结果
@NicolasMenettrier 是的，你是对的。添加了对第一级递归的验证。
如果添加相同的多个对象，它会出现一些意想不到的行为:(

【解决方案3】：

您可以使用递归生成器函数：

function* get_vals(d, target, c = []){
    for (var i of Object.keys(d)){
        if (i === target){
           yield [target, ...c.slice(0, 3)]
        }
        if (typeof d[i] === 'object'){
            yield* get_vals(d[i], target, c = [i, ...c])
        }
    }
} 
var result = get_vals(data, 'c').next().value

输出：

["c", "greatgrand", "grand", "child"]

【讨论】：