Go类型转换：利用共享接口排序不同接口的两个切片

这个需求完全可行，只是你的实现方式没踩对Go类型系统的关键点，我来拆解下问题和解决方案：

为什么原代码编译失败？ #

Go的切片类型是严格匹配的：

• []Foo 和 []Bar 是完全独立的具体类型，哪怕它们的元素都实现了Timestamper接口，也不能直接转换成同一个ByTimestamp类型。
• 如果你原来的ByTimestamp是基于某个具体类型定义的（比如type ByTimestamp []Foo），那[]Bar自然无法转换——类型不匹配是Go类型系统的硬规则。

解决方案分两种场景 #

场景1：Go 1.18+（支持泛型，推荐）

泛型是解决这类"多类型复用同一逻辑"问题的最优解，你可以定义一个泛型版的ByTimestamp，约束它的元素必须实现Timestamper接口：

import "sort"
import "time"

// 你的基础时间戳接口
type Timestamper interface {
    Timestamp() time.Time
}

// 泛型版ByTimestamp，支持所有实现Timestamper的类型切片
type ByTimestamp[T Timestamper] []T

// 实现sort.Interface的三个核心方法
func (b ByTimestamp[T]) Len() int           { return len(b) }
func (b ByTimestamp[T]) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
func (b ByTimestamp[T]) Less(i, j int) bool { return b[i].Timestamp().Before(b[j].Timestamp()) }

然后在main函数里直接用：

func main() {
    var foos []Foo
    var bars []Bar

    // 对[]Foo排序
    sort.Sort(ByTimestamp[Foo](foos))
    // 对[]Bar排序
    sort.Sort(ByTimestamp[Bar](bars))
}

这种方式既复用了排序逻辑，又能直接操作原切片的具体类型，排序后原切片类型还是[]Foo/[]Bar，不需要额外转换。

场景2：兼容旧版本Go（无泛型）

如果你的Go版本低于1.18，有两种实用的替代方式：

子方案2.1：为每个具体切片实现sort.Interface（推荐）

虽然会有少量重复代码，但可以通过辅助函数减少冗余：

// 通用的时间戳比较逻辑，所有类型复用
func lessTimestamper(a, b Timestamper) bool {
    return a.Timestamp().Before(b.Timestamp())
}

// 为[]Foo实现sort.Interface
type FooSlice []Foo

func (f FooSlice) Len() int           { return len(f) }
func (f FooSlice) Swap(i, j int)      { f[i], f[j] = f[j], f[i] }
func (f FooSlice) Less(i, j int) bool { return lessTimestamper(f[i], f[j]) }

// 为[]Bar实现sort.Interface
type BarSlice []Bar

func (b BarSlice) Len() int           { return len(b) }
func (b BarSlice) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
func (b BarSlice) Less(i, j int) bool { return lessTimestamper(b[i], b[j]) }

在main里调用：

func main() {
    var foos []Foo
    var bars []Bar

    sort.Sort(FooSlice(foos))
    sort.Sort(BarSlice(bars))
}

这种方式直接修改原切片的顺序，核心逻辑通过辅助函数复用，代码冗余度很低。

子方案2.2：转换为接口切片排序

先把具体类型切片逐个元素转换成[]Timestamper，再排序这个接口切片：

// 先把ByTimestamp定义为接口切片类型
type ByTimestamp []Timestamper

func (b ByTimestamp) Len() int           { return len(b) }
func (b ByTimestamp) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
func (b ByTimestamp) Less(i, j int) bool { return b[i].Timestamp().Before(b[j].Timestamp()) }

func main() {
    var foos []Foo
    var bars []Bar

    // 转换[]Foo为[]Timestamper
    fooTimestamps := make([]Timestamper, len(foos))
    for i, f := range foos {
        fooTimestamps[i] = f
    }
    sort.Sort(ByTimestamp(fooTimestamps))

    // 同理处理[]Bar
    barTimestamps := make([]Timestamper, len(bars))
    for i, b := range bars {
        barTimestamps[i] = b
    }
    sort.Sort(ByTimestamp(barTimestamps))
}

⚠️ 注意：这种方式排序的是接口切片，原切片foos/bars不会被修改，如果需要同步原切片的顺序，还要额外处理，适合不需要保留原切片类型的场景。

内容的提问来源于stack exchange，提问作者MAcabot