Question

我坚持使用JSON中的两个Mock数据表从平面数组创建树结构。该表应匹配两个唯一的ID，以确定它们之间的层次结构。

具有Groups数据库数组的JSON如下：

 {
"group": [
    {
        "groupName": "ROOT",
        "id": 1
    },
    {
        "groupName": "Family",
        "id": 9
    },
    {
        "groupName": "BestFriends!",
        "id": 10
    },
     {
        "groupName": "Cars",
        "id": 4
    },
      {
        "groupName": "funHouse",
        "id": 3
    }

]
 };

包含Users数组的JSON如下所示：

 {
"user": [
    {
        "username": "StrongGoose",
        "password": "sdff12fdsa",
        "age": 31,
        "id": 2
    },
    {
        "username": "John",
        "password": "sdjd34fffdsa",
        "age": 31,
        "id": 3
    },
    {
        "username": "Mary",
        "password": "sdfffdsa",
        "age": 31,
        "id": 4
    }
]
 };

这是第一个数据表的外观并确定组之间的层次结构的方式：

 {
"GroupsToGroups": [
    {
        "1":[9,10]
    },
    {
        "10":[3]
    }

]
 };

第二个类似，并确定哪个用户属于哪个组：

 {
"GroupsToUsers": [
    {
        "11":[2]
    },
    {
        "3":[3]
    },
    {
        "4":[4]
    },
    {
    "10":[2] 
    },
    {
    "3":[3] 
    }
   ]
  };

层次结构应如下所示，需要写入JSON

 [
{
    "type": "group",
    "id": "1",
    "name": "ROOT",
    "items": [
        {
            "type": "group",
            "id": "9",
            "name": "Family",
            "items": []
        },
        {
            "type": "group",
            "id": "10",
            "name": "BestFriends!",
            "items": [
                {
                    "username": "StrongGoose",
                    "password": "sdff12fdsa",
                    "age": 31,
                    "id": 2
                },

                {
                    "type": "group",
                    "id": "3",
                    "name": "funHouse",
                    "items": [
                        {
                            "username": "John",
                            "password": "sdjd34fffdsa",
                            "age": 31,
                            "id": 3
                        },
                        {
                            "type": "group",
                            "id": "4",
                            "name": "Cars",
                            "items": [
                                {
                                    "username": "Mary",
                                    "password": "sdfffdsa",
                                    "age": 31,
                                    "id": 4
                                }
                            ],
                        }
                    ]
                }
            ]
        }

    ]
  }


 ];

编辑：我试图创建具有递归功能的函数，以找到相关的相关组。它有效，但我不知道如何合并用户。

 function checkChildren(group) {
  const allChildren = insideGroups[group.id];
  if (!allChildren) return group;
  const childGroups = allChildren.map((findChildrenID) => {
      const indexGroups = groups.findIndex((subGroup) => subGroup.id === 
    findChildrenID);
    return checkChildren(groups[indexGroups]);
    });
   return Object.assign({}, group, {groups: childGroups});
   }

Answer 1

您可以为各种类型的数据创建一个哈希表，以便在不迭代对象数组的情况下更快地进行访问。

对于用户，无论如何，您都需要一个具有新属性和重命名键的新对象。

然后，您需要为根对象添加一个新属性，并将其添加到groups.groups属性中，以对所有级别具有相同的访问类型。

最后，首先groups.users，然后groups.groups进行迭代，以获取所有对象，并且对于组，也将其作为子对象。

在给定的数据中，我注释了未使用/重复的数据。

function getNodes(node) {
    return [
        ...(hash.groups.users[node] || []).map(id => hash.user[id]),
        ...(hash.groups.groups[node] || []).map(id => Object.assign(hash.group[id], { children: getNodes(id) }))
    ];
}

var db = {
        group: [
            { groupName: "ROOT", id: 1 },
            { groupName: "Family", id: 9 },
            { groupName: "BestFriends!", id: 10 },
            { groupName: "Cars", id: 4 },
            { groupName: "funHouse", id: 3 }
        ],
        user: [
            { username: "StrongGoose", password: "sdff12fdsa", age: 31, id: 2 },
            { username: "John", password: "sdjd34fffdsa", age: 31, id: 3 },
            { username: "Mary", password: "sdfffdsa", age: 31, id: 4 }
        ],
        GroupsToGroups: [
            { 1: [9, 10] }, // ok
            { 10: [3] },    // second
            { 3: [4] }
        ],
        GroupsToUsers: [
            //{ 11: [2] }, // never used
            { 3: [3] },
            { 4: [4] },
            { 10: [2] },   // first
            //{ 3: [3] }   // dupe
        ]
    },
    hash = {
        group: Object.assign(...db.group.map(({ id, groupName: name, type = 'group' }) => ({ [id]: { type, id, name } }))),
        user: Object.assign(...db.user.map(o => ({ [o.id]: o }))),
        groups: {
            groups: Object.assign(...db.GroupsToGroups, { root: db.group.filter(({ groupName }) => groupName === 'ROOT').map(({ id }) => id) }),
            users: Object.assign(...db.GroupsToUsers)
        }
    },
    result = getNodes('root');

console.log(result);

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

使用Javascript中的两个数据表从平面数组构建树

1 个答案: