Go 语言中利用接口实现结构体切片的通用迭代与ID提取

type Foo struct {
    Id   int
    Name string
}

type Bar struct {
    Id    int
    Value string
}

// 从 Foo 结构体切片中提取所有 ID
func getIdsFoo(foos []Foo) []int {
    ids := make([]int, 0, len(foos))
    for _, f := range foos {
        ids = append(ids, f.Id)
    }
    return ids
}

// 从 Bar 结构体切片中提取所有 ID
func getIdsBar(bars []Bar) []int {
    ids := make([]int, 0, len(bars))
    for _, b := range bars {
        ids = append(ids, b.Id)
    }
    return ids
}

// Identifiable 接口定义了获取 ID 的行为
type Identifiable interface {
    GetId() int
}

type Foo struct {
    Id   int
    Name string
}

// Foo 类型实现 Identifiable 接口的 GetId() 方法
func (f Foo) GetId() int {
    return f.Id
}

type Bar struct {
    Id    int
    Value string
}

// Bar 类型实现 Identifiable 接口的 GetId() 方法
func (b Bar) GetId() int {
    return b.Id
}

// GatherIds 函数接受一个 Identifiable 接口切片，并返回所有元素的 ID 组成的切片
func GatherIds(items []Identifiable) []int {
    ids := make([]int, 0, len(items)) // 预分配容量，优化性能
    for _, item := range items {
        ids = append(ids, item.GetId()) // 调用接口方法，实现多态
    }
    return ids
}

package main

import "fmt"

// 1. 定义结构体并实现Identifiable接口
type Foo struct {
    Id   int
    Name string
}

func (f Foo) GetId() int {
    return f.Id
}

type Bar struct {
    Id    int
    Value string
}

func (b Bar) GetId() int {
    return b.Id
}

// 2. 定义通用接口
type Identifiable interface {
    GetId() int
}

// 3. 构建通用ID提取函数
func GatherIds(items []Identifiable) []int {
    ids := make([]int, 0, len(items))
    for _, item := range items {
        ids = append(ids, item.GetId())
    }
    return ids
}

func main() {
    // 创建 Foo 结构体切片
    foos := []Foo{
        {Id: 101, Name: "Alpha"},
        {Id: 102, Name: "Beta"},
    }

    // 创建 Bar 结构体切片
    bars := []Bar{
        {Id: 201, Value: "Value A"},
        {Id: 202, Value: "Value B"},
        {Id: 203, Value: "Value C"},
    }

    // 注意：Go 语言中 []ConcreteType (如 []Foo) 并不是 []InterfaceType (如 []Identifiable)。
    // 即使 ConcreteType 实现了 InterfaceType，切片类型也不会自动转换。
    // 因此，需要手动遍历并逐个将具体类型的元素转换为接口类型，再构建接口切片。

    // 将 Foo 切片转换为 Identifiable 接口切片
    var identifiableFoos []Identifiable
    for _, f := range foos {
        identifiableFoos = append(identifiableFoos, f) // 单个 Foo 可以赋值给 Identifiable 接口
    }

    // 将 Bar 切片转换为 Identifiable 接口切片
    var identifiableBars []Identifiable
    for _, b := range bars {
        identifiableBars = append(identifiableBars, b) // 单个 Bar 可以赋值给 Identifiable 接口
    }

    // 使用通用函数提取 ID
    fooIds := GatherIds(identifiableFoos)
    barIds := GatherIds(identifiableBars)

    fmt.Printf("Foo IDs: %v\n", fooIds) // 输出: Foo IDs: [101 102]
    fmt.Printf("Bar IDs: %v\n", barIds) // 输出: Bar IDs: [201 202 203]

    // 也可以创建混合类型的 Identifiable 接口切片
    mixedItems := []Identifiable{
        Foo{Id: 301, Name: "Gamma"},
        Bar{Id: 401, Value: "Value D"},
        Foo{Id: 302, Name: "Delta"},
    }
    mixedIds := GatherIds(mixedItems)
    fmt.Printf("Mixed IDs: %v\n", mixedIds) // 输出: Mixed IDs: [301 401 302]
}