3

有这样一个对象,想通过nodeId获取key

{
  childNode: {
    nodeId: 'sid-start',
    childNode: {
      nodeId: 'aaaa',
      conditionNodes: [
        {
          nodeId: 'bbbb',
          childNode: {
            nodeId: 'cccc'
          }
        },
        {
          nodeId: 'dddd',
        }
      ],
      childNode: {
        nodeId: 'eeee',
      }
    }
  }
}

比如知道nodeIdcccc, 得到 childNode > childNode > conditionNodes[0] > childNode。卡了一下午了,跪求大牛们帮忙看看

_金星 22
2019-05-10 提问
3 个回答
2

已采纳

树的遍历是编程的基本功,野路子自学出身的我只能写个蹩脚的递归给你自个琢磨改进了:

const depth = (obj, value, path) => {
    for(let key in obj){
        if(obj.hasOwnProperty(key)){
            const current = obj[key];
            const subPath = [key].concat(path);
            if(current instanceof Object){
                const subResult = depth(current, value, subPath);
                if(!!subResult.length){
                    return subResult;
                }
            } else if(current === value){
                return subPath
            } else {}
        }
    }
    return []
};

出来的结果将会是反的,需要进行一次.reverse 操作。

2

想想好像除了递归,就只剩看场景取巧了。

var value = 4;

var obj = {
  a: 1,
  b: [2,3],
  c: { d: 4, e: 5 }
};

var reg = new RegExp(`[,|{]"([^"]+?)":${value}[,|}]`);
var res = JSON.stringify(obj).match(reg);
console.log(res && res[1]); // d
0

关键是为什么是复杂结构……除了逼你自己写出像一楼一样的复杂迭代外比摊平结构的数据没有任何好处

如果有什么历史场景搞得你必须要接受这种结构并有以value反查key的行为,那么先 flat 掉这个数据结构
然后再把对象喂到下边value2key函数里边

var value2key = (obj, value) => Object.entries(obj).filter(item => item[1] === value)[0][0]

var value = 1
var target = { a: 1, b: 2, c: 3 }

console.log(value2key(target, value))

撰写答案

推广链接