Go中的未知深度列表

Question

我正在尝试从数据库中获取深度未知的类别列表。是否可以使用map[int][]interface{} 并且有可能吗？

type Category struct {
    ID        int
    Name      string
    ParentID  int
}

func GetCategories(db *gorm.DB) map[int][]interface{} {
    var result = make(map[int][]interface{})
    var categories = []Category{}
    db.Where("parent_id = ?", 0).Find(&categories)
    for len(categories) > 0 {
        var ids []int
        for _, cat := range categories {
            ids = append(ids, cat.ID)
            if cat.ParentID == 0 {
                result[cat.ID] = append(result[cat.ID], cat)
            } else {

                // This work only for 2nd level ...
                result[cat.ParentID] = append(result[cat.ParentID], cat)
            }
        }
    }
    return result
}

最好的输出是 JSON 数组。例如：

[
    {id: 1, name: "Car", Parent: 0, Children: []},
    {id: 2, name: "Boat", Parent: 0, Children: [
        {id: 4, name: "Fast", Parent: 2, Children: []},
        {id: 5, name: "Slow", Parent: 2, Children: [
            {id: 6, name: "ExtraSlow", Parent: 5, Children: []},
        ]},
    ]},
    {id: 3, name: "Rocket", Parent: 0, Children: []}
]

Answer 1

我找到了解决方案！我在 Category 结构中添加了类别切片，并从存储在 [depth][]Categories{} 中的数据库中请求每一层的深度。最后将所有数据从下到上排序。

type Category struct {
    ID        int
    Name      string
    ParentID  int
    Children  []Category
}

func GetCategories(db *gorm.DB) []Category {

    // Request data from database
    var categories = []Category{}
    var store = [][]Category{}
    db.Where("parent_id = ?", 0).Find(&categories)
    for len(categories) > 0 {
        var ids []int
        for _, cat := range categories {
            ids = append(ids, cat.ID)
        }
        store = append(store, categories)
        categories = []Category{}
        db.Where("parent_id in (?)", ids).Find(&categories)
    }

    // Sort and move children to parent
    lastLayer := len(store) - 1
    for lastLayer >= 0 {
        if (lastLayer - 1 >= 0) {
            for _, child := range store[lastLayer] {
                for i, parent := range store[lastLayer -1] {
                    if parent.ID == child.ParentID {
                        store[lastLayer -1][i].Children = append(store[lastLayer -1][i].
                            Children, child)
                    }
                }
            }
        }
        lastLayer--;
    }

    return store[0]
}

// Return content as JSON response in WebApp
func Output(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(GetCategories(databaseConnection))
}

Answer 2

您应该只将每个成员存储在地图的基本级别中，然后列出其所有子级。

然后，您可以像使用数组 ids 一样使用地图。

func GetCategories(db *gorm.DB) map[int][]interface{} {
    var result = make(map[int][]interface{})
    var categories = []Category{}
    db.Where("parent_id = ?", 0).Find(&categories)
    if len(categories) > 0 {
        for _, cat := range categories {
            if _, ok := result[cat.ID]; !ok {
                result[cat.ID] = make([]interface{}, 0, 5)
            }

            if cat.ParentID != 0 {
                if _, ok := result[cat.ParentID]; !ok {
                    result[cat.ParentID] = make([] interface{}, 0, 5)
                }
                result[cat.ParentID] = append(result[cat.ParentID], cat)                
            }
        }
    }
    return result
}

目前尚不清楚您想要做什么，但这会将所有父项放在地图的条目“0”中，从而无需递归数据结构来存储您的所有类别。