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: []
        }
    ]
}

我不确定如何处理这个问题。我想到的解决方案必须反复遍历列表，以检查对象的父级是否为空，在这种情况下，它被指定为顶级对象，或对象＆＃39 ; s父级已经存在，在这种情况下，我们获取父级的路径，并将子级分配给该父级。

P.S。我不认为这是以下任何一个的副本

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**/
}

单循环旁边的主要优点是，它可以处理未排序的数据，因为结构可以同时使用keys和parent信息。

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

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

1 个答案: