Sort排序

已知一个的struct组成的数组，现在需要按照struct中的一个字段排序，可以利用golang中的Sort实现。

最简便的方法是：

使用 ​​sort.Slice​​​函数，对struct数组进行快速排序（​​sort.Slice​​函数的底层实现是快速排序）

func Slice(x interface{}, less func(i, j int) bool) {
    rv := reflectValueOf(x)
    swap := reflectSwapper(x)
    length := rv.Len()
    quickSort_func(lessSwap{less, swap}, 0, length, maxDepth(length))
}

其中x为需要排序的结构体数组，less为排序规则的函数，一般用于定义排序中依据的字段，以及是从大到小排序还是从小到大排序。具体示例如下所示：

for _, item := range events.Items {
        podEvent := &PodEvent{
            Type:           item.Type,
            Reason:         item.Reason,
            Message:        item.Message,
            LastUpdateTime: baseTools.GetTimeAgo(item.LastTimestamp.Time),
            timeUnix:       baseTools.TimeBucketSecond(item.LastTimestamp.Time),
        }
        podEvents = append(podEvents, podEvent)
    }
    sort.Slice(podEvents, func(i, j int) bool {
        return podEvents[i].timeUnix > podEvents[j].timeUnix
    })
    return podEvents, nil

​​podEvents​​ ​为 ​​podEvent​​ ​这个结构体的实例化数组，在​​sort.Slice​​​函数中传入该数组作为需要排序的结构体数组，

func(i, j int) bool {
    return podEvents[i].timeUnix > podEvents[j].timeUnix
}

接着在​​sort.Slice​​​函数中传入上面的函数作为排序规则，该函数代表了排序根据 ​​podEvent​​ 这个结构体中的 ​​timeUnix​​ 字段，进行从大到小的排序。

除此之外，还可以利用​​sort.Sort(data)​​方法自己实现排序。

使用 ​​sort.Sort(data)​​方法前，方法中传参的data的接口类型需要实现对应的三个方法，代码示例如下：

type PackageVersionInfo struct {
    AppId string `json:"appId"`
    CreateTime int64 `json:"createTime"`
    UpdateTime int64 `json:"updateTime"`
    PackageVersion string `json:"PackageVersion"`
    PackageVersionId string `json:"Id"`
}

type PackageVersion []PackageVersionInfo

func (p PackageVersion) Swap(i, j int) {
    p[i], p[j] = p[j], p[i]
}

func (p PackageVersion) Len() int {
    return len(p)
}

func (p PackageVersion) Less(i, j int) bool {
    return p[i].CreateTime > p[j].CreateTime
}