Sorting golang排序切片升序或降序

我需要对来自第三方软件包的类型片段进行排序。根据某些条件，顺序必须是升序或降序

我提出的解决方案是：

type fooAscending []foo

func (v fooAscending) Len() int           { return len(v) }
func (v fooAscending) Swap(i, j int)      { v[i], v[j] = v[j], v[i] }
func (v fooAscending) Less(i, j int) bool { return v[i].Amount < v[j].Amount }

type fooDescending []foo

func (v fooDescending) Len() int           { return len(v) }
func (v fooDescending) Swap(i, j int)      { v[i], v[j] = v[j], v[i] }
func (v fooDescending) Less(i, j int) bool { return v[i].Amount > v[j].Amount }

if someCondition {
    sort.Sort(fooAscending(array))
} else {
    sort.Sort(fooDescending(array))
}

输入foo[]foo
func（v）Len（）int{return Len（v）}
func（v）Swap（i，j int）{v[i]，v[j]=v[j]，v[i]}
func（v）Less（i，j int）bool{return v[i]。Amountv[j].Amount}
如果有某种情况{
sort.sort（数组）
}否则{
排序（数组）
}

有没有更好的办法。这个任务有13行代码，而且大部分代码都是重复的，似乎有点太多了。

您正在寻找的。你可以这样说：

sort.Sort(sort.Reverse(fooAscending(s)))

---

从Go 1.8开始，有一种更简单的方法可以对切片进行排序，而不需要定义新类型。只需将匿名函数传递给

sort.Slice

函数

a := []int{5, 3, 4, 7, 8, 9}
sort.Slice(a, func(i, j int) bool {
    return a[i] < a[j]
})
for _, v := range a {
    fmt.Println(v)
}

a:=[]int{5,3,4,7,8,9}
sort.Slice（a，func（i，j int）bool{
返回a[i]

---

这将按升序排序，如果您想要相反的顺序，只需在匿名函数中写入

a[i]>a[j]

。

我下面的回答基于这样的假设，即您从第三方软件包收到的切片是基本Go类型

a := []int{5, 3, 4, 7, 8, 9}
sort.Slice(a, func(i, j int) bool {
    return a[i] < a[j]
})
for _, v := range a {
    fmt.Println(v)
}

要对基本类型的切片进行排序，请使用排序包实用程序。下面是一个对字符串片段和int片段进行排序的示例

package main

import (
    "fmt"
    "sort"
)

func main() {
    sl := []string{"mumbai", "london", "tokyo", "seattle"}
    sort.Sort(sort.StringSlice(sl))
    fmt.Println(sl)

    intSlice := []int{3,5,6,4,2,293,-34}
    sort.Sort(sort.IntSlice(intSlice))
    fmt.Println(intSlice)
}

上面的输出是：

[london mumbai seattle tokyo]
[-34 2 3 4 5 6 293]

你自己去试试吧

有几点值得注意：

排序基本Go类型不需要实现属于sort.Interface的函数，如Len（）。您只需要为复合类型选择该路径

只需使用适当的接口方法提供程序包装基本类型的类型，例如or和sort

切片已就地排序，因此不会返回已排序切片的副本

---

Go Playgound的链接

遗憾的是，它被限制在int上type@LewisChan它不受int类型的限制；int参数是切片的索引，切片可以是字符串切片。