我有一个表示菜单项的 JSON。

一个菜单项可以有一个子菜单项，子菜单项又可以有另一个子菜单项等等。

输入 JSON 通过父 ID 关联菜单项。我正在尝试将其转换为一个模型，其中每个菜单项都有其子菜单项的一部分。

子菜单分为三层。我已经设法解析了两个级别，但我不知道为什么不解析第三个级别。我已经调试这个问题好几个小时了。我将不胜感激。

menu2.sjon

[
  {
    "category_id": 4,
    "category_id_400": "'SCHOO",
    "name": "School Supplies",
    "parent_id": 2,
    "position": 2,
    "level": 2,
    "status": 1,
    "url": "http://www.booksrus.kw/sa-en/school-supplies.html"
  },
  {
    "category_id": 141,
    "category_id_400": "'SCHBA",
    "name": "School Bags",
    "parent_id": 4,
    "position": 12,
    "level": 3,
    "status": 1,
    "url": "http://www.booksrus.kw/sa-en/school-supplies/school-bags.html"
  },
  {
    "category_id": 269,
    "category_id_400": "'AEP",
    "name": "Bags Knapsack with Trolley",
    "parent_id": 141,
    "position": 1,
    "level": 4,
    "status": 1,
    "url": "http://www.booksrus.kw/sa-en/school-supplies/school-bags/bags-knapsack-with-trolley.html"
  }
]

menu.go

package main

import(
    "fmt"
    "encoding/json"
    "io/ioutil"
    "sort"
    "bytes"
)

type MenuItems []MenuItem

func (a MenuItems) Len() int           { return len(a) }
func (a MenuItems) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a MenuItems) Less(i, j int) bool { return a[i].Category_id < a[j].Category_id }

type MenuItem struct{
    Category_id int `json:"category_id"`
    Category_id_400 string `json:"category_id_400"`
    Name string `json:"name"`
    Parent_id int `json:"parent_id"`
    Position int `json:"position"`
    Level int `json:"level"`
    Status int `json:"status"`
    Url string  `json:"url"`
    Subs []MenuItem `json:"subs"`
}

func (m MenuItem) String() string{

     var buffer bytes.Buffer
     buffer.WriteString(fmt.Sprintf("%d %s\n",m.Category_id,m.Name))
    for _,s := range m.Subs{
        buffer.WriteString(fmt.Sprintf(">   %s\n",s.String()));
    }

    return buffer.String()
    //return fmt.Sprintf("CategoryId: %d, ParentId: %d,Name: %s, Sub: %v\n",m.Category_id,m.Parent_id,m.Name,m.Subs);
}

func (m *MenuItem) TryAdd(other MenuItem) bool{

    if other.Parent_id == m.Category_id {

        m.Subs = append(m.Subs,other);
        return true
    }else{
        for _,sub := range m.Subs{
            if found := sub.TryAdd(other);found{
                return true
            }
        }
    }

    return false
}

func main() {
    rootItems := make([]MenuItem,0)
    bytes, err := ioutil.ReadFile("menu2.json")

    if err != nil{
        fmt.Printf("Reading: %s\n",err.Error())
        return;
    }

    var menuItems []MenuItem
    err = json.Unmarshal(bytes,&menuItems)

    if err != nil{
        fmt.Println(err.Error())
        return
    }

    sort.Sort(MenuItems(menuItems))

    for _,item := range menuItems{
        if item.Parent_id == 2{
            rootItems = append(rootItems,item)
        }else{
            for i:=0;i<len(rootItems);i++{
                if found := rootItems[i].TryAdd(item); found{
                    break;
                }else{
                    fmt.Printf("No Action: Id: %d, Name: %s, Parent: %d.\n",item.Category_id,item.Name,item.Parent_id)
                }
            }
        }
    }

    fmt.Printf("\nRootitems:\n%s\n",rootItems)
}

输出

Rootitems:
[4           School Supplies
>   141           School Bags
//Third level should appear here
]

最佳答案

TryAdd 函数中的这个循环很可能是您的问题:

for _, sub := range m.Subs {
    if found := sub.TryAdd(other); found {
        return true
    }
}

此循环中的 sub 变量实际上是 slice 元素的副本。您在那里所做的任何更改都不会保留回存储在 slice 中的元素。

你应该能够通过不使用元素的副本来解决这个问题，而是通过它的索引来引用它:

for i := range m.Subs {
    if found := m.Subs[i].TryAdd(other); found {
        return true
    }
}

关于json - 解析嵌套列表不会下降到第 3 级，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/34841327/