递归遍历对象创建父子关系答案

【问题标题】：Recursively go through object to create parent child relationships递归遍历对象创建父子关系
【发布时间】：2018-01-30 01:49:57
【问题描述】：

我一直在尝试根据我在这里得到的帮助创建一个递归函数：looping through an object (tree) recursively

我想遍历对象 o 并创建一个新对象，该对象以每个键为键，并且对它上面的所有内容都具有父母的价值。

我的大脑不擅长递归，试试看 :-) .. 如果你想尝试使用真实数据，它是 here

function eachRecursive(obj) {
    for (var k in obj) {
        if (typeof obj[k] == "object" && obj[k] !== null ) {
            eachRecursive(obj[k])
        }
        else {
            // do something to add to codes
        }
    }
}

var o = {
    "1": {
        name: "hi 1",
        children: {
            "1.1": {
                name: "hi 1.1",
                children: {
                    "1.1.1": {
                        name: "hi 1.1.1",
                        children: {}
                    }
                }
            },
            "1.2": {
                name: "hi 1.2",
                children: {}
            }
        }
    },
    "2": {
        name: "hi 2",
        children: {
            "2.1": {
                name: "hi 2.1",
                children: {}
            }
        }
    }
}

var codes = {}
eachRecursive(o)
console.log(codes)
// What I wish to have.
//{
//    "1": {
//        "name":"hi 1",
//        "parents":[]
//    },
//    "2": {
//        "name": "hi 2",
//        "parents": []
//    },
//    "1.1": {
//        "name": "hi 1.1",
//        "parents": ["1"]
//    },
//    "1.1.1": {
//        "name": "hi 1.1.1",
//        "parents": ["1", "1.1"]
//    },
//    "1.2": {
//        "name": "hi 1.2",
//        "parents": ["1"]
//    },
//    "2.1": {
//        "name": "hi 2.1",
//        "parents": ["2"]
//    }
//}

【问题讨论】：

您可能想要使用映射函数并返回每个项目的值
将再试一次 - 问题是 parents 部分，这使得递归解决方案更加烦人。如果我不回到这个 - 你可能想看看这个库 - github.com/paularmstrong/normalizr

标签： javascript json recursion

【解决方案1】：

你可以这样做：

function eachRecursive(obj) {
    return (function recurse(result, obj, parents) {
        for (var key in obj || {}) {
            result[key] = { name: obj[key].name, parents: [...parents] };
            recurse(result, obj[key].children, parents.concat(key));
        }
        return result;
    })({}, obj, []);
}


var o = {
    "1": {
        name: "hi 1",
        children: {
            "1.1": {
                name: "hi 1.1",
                children: {
                    "1.1.1": {
                        name: "hi 1.1.1",
                        children: {}
                    }
                }
            },
            "1.2": {
                name: "hi 1.2",
                children: {}
            }
        }
    },
    "2": {
        name: "hi 2",
        children: {
            "2.1": {
                name: "hi 2.1",
                children: {}
            }
        }
    }
}

var codes = eachRecursive(o);
console.log(codes);

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

【讨论】：

【解决方案2】：

你必须一步一步地思考如何手工完成。

如果是对象：将实际节点添加到结果中，然后使用扩展父节点和结果递归调用函数。
如果不是对象：只需将其附加到结果中即可。

我在这里为你创建了一个小提琴：https://jsfiddle.net/11e8e4af/

function eachRecursive(obj) {
  var parents = arguments[1] || [];
  var result = arguments[2] || {};
  for (var k in obj) {
    if (obj.hasOwnProperty(k) && typeof obj[k] == "object" && obj[k] !== null ) {
      result[k] = {name:obj[k].name, parents:parents.slice()};
      eachRecursive(obj[k].children, parents.concat(k), result);
    } else {
      result[k] = {name:obj[k].name, parents:parents.slice()};
    }
  }
  return result;
}

【讨论】：