Go slices 怎样按比较函数稳定排序结构体切片

Go 结构体切片需要按自定义规则排序、并保留同级元素原顺序时，使用 slices.SortStableFunc。比较函数返回负数、0、正数，分别表示排在前面、等价、排在后面；稳定性只作用于返回 0 的元素。函数原地修改切片，不返回新切片，需要保留原输入时先 slices.Clone。

例如任务列表已有接收顺序，现在要优先处理高优先级任务，同时让同优先级任务继续按原顺序排列。这是稳定排序的直接用途；它不等于“自动按时间字段排序”，也不等于“所有字段都相同才算相等”。以下示例为原创教学数据，未在本机编译运行。

官方地址：https://pkg.go.dev/slices

先区分同级保序与增加次级排序键

假设 Task 包含 ID 和 Priority。若业务只按 Priority 比较，那么 Priority 相同的两个 Task 即使 ID 不同，也应让比较器返回 0。SortStableFunc 就会保留它们在输入中的相对顺序。

反过来，如果同级时继续比较 ID，就已经定义了新的先后规则，不再要求这两个元素保留接收顺序。稳定排序不是额外的隐形排序键；比较器决定哪些元素等价，算法决定等价元素是否保持原相对位置。

从索引比较改成元素比较

标准库 slices 与 cmp 在 Go 1.21 加入。旧的 sort.SliceStable 仍可以完成任务，不是失效接口；主要区别在于旧写法用索引访问切片并返回 bool，而 SortStableFunc 直接拿到两个元素并返回三态结果。

下面是旧接口调用片段，前提是已经导入 sort，tasks 为 []Task。不要把其中的 bool 回调直接粘到新接口。

// 旧接口接收索引，返回a是否严格排在b前面；它仍然可以正确工作。
sort.SliceStable(tasks, func(i, j int) bool {
    return tasks[i].Priority > tasks[j].Priority
})

新接口中，负数表示第一个参数在前面。若 Priority 越大越靠前，使用 cmp.Compare(b.Priority, a.Priority) 即可反向比较。相等时仍返回 0，才能保留同级顺序。

用 SortStableFunc 完成任务列表排序

这段完整代码先复制输入，再按优先级降序稳定排序。ID 只用于区分示例任务，不参与第一版比较规则。

package main

import (
    "cmp"
    "fmt"
    "slices"
)

type Task struct {
    ID string
    Priority int
}

// 优先级大的排在前面，同级返回0，不再按ID打破平局。
func byPriority(a, b Task) int {
    return cmp.Compare(b.Priority, a.Priority)
}

func main() {
    incoming := []Task{
        {ID: "Cedar", Priority: 2},
        {ID: "Maple", Priority: 1},
        {ID: "Birch", Priority: 2},
        {ID: "Pine", Priority: 1},
    }

    // 排序会修改传入切片，先浅复制，保护incoming的元素顺序。
    ordered := slices.Clone(incoming)
    slices.SortStableFunc(ordered, byPriority)

    for _, task := range ordered {
        fmt.Println(task.ID, task.Priority)
    }
    // 比较器按Priority判断相等，Cedar与Birch的先后应保留。
    fmt.Println("原输入首项:", incoming[0].ID)
}

读者自行运行时，按代码语义预期的任务顺序是 Cedar、Birch、Maple、Pine：高优先级组在前，组内保留输入顺序。这是预期结果解释，不是本文的运行记录。incoming 的排列应保持不变，因为排序对象是 Clone 得到的 ordered。

若业务真正想要“优先级降序，同级按 ID 升序”，将比较器改为下面的独立函数，再把它传给同一个 SortStableFunc。它复用上面的 Task 与 cmp 导入。

// 只在业务明确要求同级按ID排列时，才增加这个次级键。
func byPriorityThenID(a, b Task) int {
    if n := cmp.Compare(b.Priority, a.Priority); n != 0 {
        return n
    }
    return cmp.Compare(a.ID, b.ID)
}

这时稳定性只保留 Priority 和 ID 在这个比较器下都等价的元素顺序。不要在需求没变时随手加 ID 作为兜底，否则原本期待的同级接收顺序就会被改变。

让比较器满足一致的顺序规则

比较器需要满足严格弱序约束。对普通优先级整数而言，理解成几个实用要求即可：同一元素与自身比较为 0；互换参数时顺序应一致反向；如果 a 在 b 前、b 在 c 前，不能又让 c 在 a 前。排序期间不要让规则依赖不断变化的随机数、当前时间或被其他 goroutine 修改的数据。

不要用 a.Priority-b.Priority 充当通用比较器，大整数相减可能溢出，反而改变比较符号。cmp.Compare 直接给出三态比较结果；降序就交换参数，而不是把不可靠的相减结果再取负。

比较函数只读元素，不应顺手修改切片或有状态地更改排序键。如果结构体含浮点字段并可能出现 NaN，应明确采用 cmp.Compare 的 NaN 规则或其他满足顺序约束的规则，不要用随意的相减和强制转换掩盖问题。

确认原地行为和版本边界

一个容易误会的地方是把 ordered := incoming 当作复制。两者仍共享底层数组，排序 ordered 会影响 incoming 看到的排列。Clone 能隔离元素位置，但如果元素里的指针指向同一对象，修改那个对象仍可能相互影响。

稳定排序也不能修复输入的不确定性。如果数据最初来自 map 遍历，原顺序本就不是你要求的业务顺序；要获得跨次运行一致的结果，就需要明确排序键或在数据进入切片前建立有意义的顺序。只把 SortFunc 换成 SortStableFunc 并不自动解决这个问题。

SortStableFunc 能接收 []Task 吗？

可以，回调参数就是 Task，不需要把切片转成接口切片。示例展示的是值类型结构体；指针切片还需要自行决定 nil 元素怎么比较。

SortFunc 结果看起来也保序，能依赖吗？

不能。SortFunc 不保证稳定，即使某组输入偶然保持了相对位置，也不是它提供的契约。

稳定排序是不是一定更慢？

本文不做没有测量依据的速度结论。先按业务语义选择，再用真实数据分布、结构体大小和比较器成本做项目内评估；示例没有性能实测数据。

参考文档：https://pkg.go.dev/slices#SortStableFunc、https://pkg.go.dev/slices#SortFunc、https://pkg.go.dev/slices#Clone、https://pkg.go.dev/cmp#Compare。