一种灵活而优雅的方式来排序Go中的结构片[关闭]

Question

假设我们有一个相当复杂的struct，有许多字段，我需要根据不同的标准在几个地方进行排序，例如。

type MySuperType struct {
    x0, x1, x2, x3 xType
    // possibly even more fields
}
// sort 1: ascending x0, then descending x1, then more stuff
// sort 2: if x4==0 then applyCriteria2a else applyCriteria2b

func f1(mySuperSlice []MySuperType) {
    // sort 'myList' according sort #1
    // do something with the sorted list
}
func f2(mySuperSlice []MySuperType) {
    // sort 'myList' according sort #2
    // do something with the sorted list
}
func f3(mySuperSlice []MySuperType) {
    // sort 'myList' according sort #1, note: we use sort #1 again!
    // do something with the sorted list
}

建议的解决方案1：
创建一个实现排序的新类型（[]MySuperType的别名）。
问题：（i）有一些重复的代码，因为函数Len和Swap是相同的（ii）会有一堆新的类型这对程序的整体可读性没有帮助——这些新类型并不能真正代表任何东西，另外唯一真正重要的是less函数。

建议的解决方案2:
使用排序。Slice
这将是一个完美的解决方案（请参见此答案），但据我所知，排序函数必须内联指定（我在别处尝试定义它时，得到一个错误无效的接收器类型[]T（[]T为未命名类型），这意味着我需要为[]T定义一个别名，现在回到解决方案1）
现在，定义内联函数的问题是：（i）鉴于MySuperType的复杂性，函数可能非常长，（ii）函数将在多个位置重复（例如，在上面的示例中，在f1和f3中）——由于排序函数可能很长且复杂，因此比解决方案1中的要烦人得多
注意：（i）如果我们没有（ii）实际

问题：
鉴于我目前对围棋的理解和知识，我会使用解决方案1
但是有人知道一种不同的方法可以优雅地解决这个问题吗？或者有人知道改进上面列出的缺点的建议吗？




Answer 1

您还可以省略额外的函数，并在需要时调用sort。

type MySuperType struct {
    x0, x1, x2, x3 string
}

func f1() {
    fields := []MySuperType {
        { "a1", "b4", "c3", "d2" },
        { "a2", "b1", "c2", "d3" },
        { "a3", "b1", "c4", "d1" },
        { "a4", "b3", "c1", "d4" },
    }
    sort.SliceStable(fields, func(i, j int) bool {
        return fields[i].x1 < fields[j].x1 || fields[i].x2 > fields[j].x2
    })
    fmt.Println("by x1, then x2: ", fields)
}

结果：x1，然后x2：[{a3 b1 c4 d1}{a2 b1 c2 d3}{a4 b3 c1 d4}{a1 b4 c3 d2}]

Answer 2

@ThunderCat的解决方案将起作用。另一种选择是编写函数，在片上返回与sort的less参数的签名匹配的闭包。切片：

func ascX0DescX1(s []MySuperType) (func(int, int) bool) {
    return func(i, j int) bool {
        if s[i].x0 == s[j].x0 {
            return s[i].x1 > s[j].x1
        }
        return s[i].x0 < s[j].x0
    }
}

然后将其作为lessarg传递给sort。切片：

sort.Slice(mySuperSlice, ascX0DescX1(mySuperSlice))

Answer 3

为f1、f2和f3的每个排序和调用编写排序函数：

func sortByX0AscX1Desc(s []MySuperType) {
    sort.Slice(s, func(i, j int) bool {
        switch {
        case s[i].x0 < s[j].x0:
            return true
        case s[i].x0 > s[j].x0:
            return false
        case s[i].x1 > s[j].x1:
            return true
        default:
            return false
        }
    })
}

func f1(mySuperSlice []MySuperType) {
    sortByX0AscX1Desc(mySuperSlice)
    // do something with the sorted list
}
func f2(mySuperSlice []MySuperType) {
    sortBySomethingElse(mySuperSlice)
    // do something with the sorted list
}
func f3(mySuperSlice []MySuperType) {
    sortByX0AscX1Desc(mySuperSlice)
    // do something with the sorted list
}