javascript - 如何找到对象中深层嵌套的唯一键的路径并相应地分配子对象？

Question

使用给定的平面列表:

let list = [
    {
        key: 1,
        parent: null,
    },
    {
        key: 2,
        parent: 1,
    },
    {
        key: 3,
        parent: null,
    },
    {
        key: 4,
        parent: 1,
    },
    {
        key: 5,
        parent: 2,
    }
]

如何创建如下所示的嵌套对象？

let nest = {
    children: [
        {
            key: 1,
            children: [
                {
                    key: 2,
                    children: [
                        {
                            key: 5,
                            children: []
                        }
                    ]
                },
                {
                    key: 4,
                    children: []
                }
            ]
        },
        {
            key: 3,
            children: []
        }
    ]
}

我不知道如何解决这个问题。我想到的解决方案必须一遍又一遍地迭代列表，以检查对象的父对象是否为空(在这种情况下它被分配为顶级对象)，或者对象的父对象已经存在，其中在这种情况下，我们获取父级的路径，并将子级分配给该父级。

附注 我不认为这与以下任何内容重复

• this检查平面对象中的键。
• this在给定唯一键的情况下，不会显示任何会返回路径的内容。

Answer 1

为了构建树，您可以使用单循环方法，不仅使用给定的key来构建节点，还使用parent来构建节点节点，密度明显。

它使用一个对象，其中所有键都用作引用，例如

{
    1: {
        key: 1,
        children: [
            {
                /**id:4**/
                key: 2,
                children: [
                    {
                        /**id:6**/
                        key: 5,
                        children: []
                    }
                ]
            },
            {
                /**id:8**/
                key: 4,
                children: []
            }
        ]
    },
    2: /**ref:4**/,
    3: {
        key: 3,
        children: []
    },
    4: /**ref:8**/,
    5: /**ref:6**/
}

除了单循环之外的主要优点是，它可以处理未排序的数据，因为其结构同时使用键和父信息。

var list = [{ key: 1, parent: null, }, { key: 2, parent: 1, }, { key: 3, parent: null, }, { key: 4, parent: 1, }, { key: 5, parent: 2, }],
    tree = function (data, root) {
        var r = [], o = {};
        data.forEach(function (a) {
            var temp = { key: a.key };
            temp.children = o[a.key] && o[a.key].children || [];
            o[a.key] = temp;
            if (a.parent === root) {
                r.push(temp);
            } else {
                o[a.parent] = o[a.parent] || {};
                o[a.parent].children = o[a.parent].children || [];
                o[a.parent].children.push(temp);
            }
        });
        return r;
    }(list, null),
    nest = { children: tree };

console.log(nest);

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