Go语言中高效排序结构体切片：利用嵌入避免重复实现Len和Swap

package main

import (
    "fmt"
    "sort"
)

// T 结构体定义
type T struct {
    Foo int
    Bar int
}

// TVector 是我们基础的结构体切片类型
type TVector []T

// Len 方法：返回切片长度
func (v TVector) Len() int {
    return len(v)
}

// Swap 方法：交换切片中两个元素的位置
func (v TVector) Swap(i, j int) {
    v[i], v[j] = v[j], v[i]
}

// Less 方法：默认比较逻辑，按Foo字段升序
func (v TVector) Less(i, j int) bool {
    return v[i].Foo < v[j].Foo
}

// TVectorBarOrdered 嵌入 TVector，并重写 Less 方法，按 Bar 字段排序
type TVectorBarOrdered struct {
    TVector // 嵌入 TVector，自动继承 Len 和 Swap
}

// Less 方法：按 Bar 字段升序
func (v TVectorBarOrdered) Less(i, j int) bool {
    return v.TVector[i].Bar < v.TVector[j].Bar
}

// TVectorArbitraryOrdered 嵌入 TVector，并添加 Reversed 字段实现动态排序
type TVectorArbitraryOrdered struct {
    Reversed bool    // 控制排序方向
    TVector          // 嵌入 TVector，自动继承 Len 和 Swap
}

// Less 方法：根据 Reversed 字段决定按 Foo 字段正向或反向排序
func (v TVectorArbitectorArbitraryOrdered) Less(i, j int) bool {
    // 如果 Reversed 为 true，则交换 i 和 j，实现反向排序
    if v.Reversed {
        i, j = j, i
    }
    return v.TVector[i].Foo < v.TVector[j].Foo
}

func main() {
    data := []T{{1, 3}, {0, 6}, {3, 2}, {8, 7}}

    // 1. 按 Foo 字段默认排序
    fmt.Println("原始数据:", data)
    sort.Sort(TVector(data)) // 将 []T 转换为 TVector 类型进行排序
    fmt.Println("按 Foo 排序:", data)

    // 恢复原始数据，以便进行其他排序
    data = []T{{1, 3}, {0, 6}, {3, 2}, {8, 7}}

    // 2. 按 Bar 字段排序
    // 注意：这里需要创建一个新的 TVectorBarOrdered 实例，并传入原始切片
    sort.Sort(TVectorBarOrdered{TVector: data})
    fmt.Println("按 Bar 排序:", data)

    // 恢复原始数据
    data = []T{{1, 3}, {0, 6}, {3, 2}, {8, 7}}

    // 3. 动态排序：按 Foo 字段反向排序
    // 创建 TVectorArbitraryOrdered 实例，设置 Reversed 为 true
    sort.Sort(TVectorArbitraryOrdered{Reversed: true, TVector: data})
    fmt.Println("按 Foo 反向排序:", data)
}