sort.Slice 最灵活常用，无需实现 sort.Interface，适合临时多字段排序；常见错误是传入错误比较表达式。

Go 语言原生 sort 包足够好用，但直接调用 sort.Sort 或泛型函数前，必须明确：你排序的是什么类型、是否要自定义规则、是否要保持原 slice 独立性。

用 sort.Slice 快速实现任意结构体字段排序

这是最常用也最灵活的方式，无需实现 sort.Interface，适合临时、多字段、带条件的排序。

常见错误是传入错误的比较表达式，比如用 替代 ，导致排序不稳定甚至 panic；或在闭包中意外

• 比较函数必须返回 bool：当前元素是否应排在另一元素之前
• 索引访问用 a[i] 和 a[j]，别写成 a[i].Field > a[j].Field（方向反了）
• 字符串忽略大小写排序：用 strings.ToLower(a[i].Name)
• 多级排序（先按 Status，再按 CreatedAt）：用逻辑或 || 链接条件

type User struct {
    Name     string
    Age      int
    Active   bool
    CreatedAt time.Time
}
users := []User{{"Alice", 30, true, time.Now().Add(-24  time.Hour)},
{"bob", 25, false, time.Now().Add(-2  time.Hour)}}
sort.Slice(users, func(i, j int) bool {
if users[i].Active != users[j].Active {
return users[i].Active // active 在前
}
return users[i].CreatedAt.Before(users[j].CreatedAt)
})

对基本类型 slice 使用 sort.Ints / sort.Strings 等专用函数

比 sort.Slice 快且安全，编译器可做更多优化。但只适用于内置类型，且不支持逆序或自定义逻辑。

容易踩的坑是误以为这些函数返回新 slice —— 它们直接修改原 slice，且无返回值。若需保留原数据，必须先 copy。

• sort.Ints([]int{3,1,4}) → [1 3 4]（原地修改）
• 逆序整数？用 sort.Sort(sort.Reverse(sort.IntSlice(nums)))
• sort.Float64s 对 NaN 的处理是未定义行为，务必提前过滤
• sort.Strings 是字典序，不是自然排序（"file10.txt" 会排在 "file2.txt" 前）

实现 sort.Interface 用于复用或复杂逻辑

当同一类型需要多种排序策略（如按 ID、按更新时间、按权重），或需与第三方库（如 container/heap）集成时，显式实现接口更清晰。

关键点在于：三个方法必须作用于同一底层数据，且 Less 必须满足严格弱序（不可同时有 a 和 b 为真）。

• Len() 返回 len(s)，不是指针长度
• Swap(i,j) 要交换元素值，不是地址（Go slice 是引用头，但元素仍需逐个赋值）
• 若结构体含指针字段，Less 中解引用前检查 nil，否则 panic
• 导出类型建议命名如 ByAge、ByNameDesc，便于调用方理解意图

type ByAge []User
func (a ByAge) Len() int           { return len(a) }
func (a ByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }
sort.Sort(ByAge(users))

注意 slice 底层共享与排序副作用

Go 中所有 slice 共享底层数组，sort 函数不会分配新数组。这意味着：如果两个 slice 指向同一底层数组的不同片段，一个排序可能意外影响另一个。

这个问题在参数传递、切片拼接（append）、或从 map value 取 slice 时极易被忽略。

• 确认是否需要独立副本：用 copy(dst, src) 或 append([]T(nil), src...)
• 对 map 中的 slice 排序前，先判断是否已存在别名引用
• 并发场景下，绝不要在多个 goroutine 中同时排序同一 slice
• benchmark 时，避免因底层数组复用导致缓存效应干扰结果

真正难的不是写对排序逻辑，而是判断该不该排序、该不该复制、以及谁还持有同一底层数组的引用——这些往往只在生产环境的数据流变复杂后才暴露。