8wDlpd.png
8wDFp9.png
8wDEOx.png
8wDMfH.png
8wDKte.png

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

Sa J 1月前

23 0

使用给定的平面列表:let list = [ { key: 1, parent: null, }, { key: 2, parent: 1, }, { key: 3, parent: null, }, { ...

使用给定的平面 列表

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

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

PSI 认为这不是以下任何内容的重复

  • 将检查平面物体中是否存在键。
  • 并没有显示任何可以返回路径的内容。
帖子版权声明 1、本帖标题:如何找到对象中深度嵌套的唯一键的路径并相应地分配子对象?
    本站网址:http://xjnalaquan.com/
2、本网站的资源部分来源于网络,如有侵权,请联系站长进行删除处理。
3、会员发帖仅代表会员个人观点,并不代表本站赞同其观点和对其真实性负责。
4、本站一律禁止以任何方式发布或转载任何违法的相关信息,访客发现请向站长举报
5、站长邮箱:yeweds@126.com 除非注明,本帖由Sa J在本站《object》版块原创发布, 转载请注明出处!
最新回复 (0)
  • 为了构建树,您可以使用单循环方法,不仅使用给定的方法 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; }
返回
作者最近主题: