golang 无限下级菜单 根据字段 自定义排序

框架  : GIN

ORM : XORM

无限下级菜单 根据数据库字段 自定义排序

考点:

Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。

Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。

type Menu struct {
   Id            int    `xorm:"pk"                 xorm:"autoincr"`
   ParentId      int    `xorm:"default(0)"`
   Listorder     int    `xorm:"default(0)"`
   Level         int `xorm:"- <- ->"`
}

var menuOneList = make([]*Menu, 0)//无限下级循环数组 一维


func (*Menu)GetMenuList() []*Menu{

   var menulist []*Menu
   err := MainOrm.Find(&menulist)
   utils.ReportError(err)
   menuOneList = make([]*Menu,0) //初始化
   buildData(menulist) //遍历数据
   return menuOneList

}

func buildData(list []*Menu)[]*Menu {
   //先把所有同样父级作为同个数组
   var data = make(map[int]map[int]*Menu)
   for _, v := range list {
      id := v.Id
      fid := v.ParentId
      if _, ok := data[fid]; !ok {
         data[fid] = make(map[int]*Menu)
      }
      data[fid][id] = v
   }


   var tmpArr = make([]*Menu, 0)
   //先把最顶级的拿出来
   for _, v := range data[0]{
      tmpArr = append(tmpArr, v)
   }
   //开始自定义排序最顶级的
   sortArr := NewMapSorter(tmpArr)
   sort.Sort(sortArr)
   //循环第一个顶级的 找出她的下级递归
   for _,v := range sortArr{
      menuOneList = append(menuOneList, tmpArr[v.Key]) //赋值全局变量
      makeTreeCore(tmpArr[v.Key].Id,data,0) //递归开始
   }
   return menuOneList
}

//递归下级
func makeTreeCore(index int, data map[int]map[int]*Menu,level int){

   var tmpArr = make([]*Menu, 0)
   //循环当前变成一维
   for _, item := range data[index] {
      item.Level = level
      tmpArr = append(tmpArr, item)
   }
   //排序
   sortArr := NewMapSorter(tmpArr)
   sort.Sort(sortArr)

   //开始循环找下级、赋值
   for _,v := range sortArr{
      menuOneList = append(menuOneList, tmpArr[v.Key])
      if data[tmpArr[v.Key].Id] != nil {
         makeTreeCore(tmpArr[v.Key].Id, data,level+1)
      }
   }

}

// sort.sort 包函数规定写法
//自定义 切片
type MapItem struct {
   Id int
   Key int
   Listorder int
}

type MapSorter []MapItem

func NewMapSorter(m []*Menu) MapSorter {
   ms := make(MapSorter, 0, len(m))
   for k, v := range m {
      ms = append(ms, MapItem{Id:v.Id,Key: k,Listorder:v.Listorder})
   }
   return ms
}

func (ms MapSorter) Len() int {
   return len(ms)
}

func (ms MapSorter) Swap(i, j int) {
   ms[i], ms[j] = ms[j], ms[i]
}

//按键排序
func (ms MapSorter) Less(i, j int) bool {
   var d bool = true
//如果排序值一样
   if ms[i].Listorder == ms[j].Listorder{
      d = ms[i].Id < ms[j].Id
   }else{
//则比较ID
      d = ms[i].Listorder < ms[j].Listorder
   }
   return d
}