Go中如何从接口值集合获取具体类型值并减少重复代码

问题场景 #

现有一组实现了IProduct接口的类型（如Foo、Bar），以及多层映射结构Products存储这些接口值。需要编写函数从集合中提取特定类型的切片（如AllFoos、AllBars），但这类函数存在大量重复代码，新增类型时重复问题会更严重。C++可以用模板解决，Go中该如何处理？

原代码如下：

package main

import (
    "fmt"
)

type IProduct interface {
    GetName() string
    GetId()   int
}

type Product struct {
    name string
    id   int
}

func (p *Product) GetName() string {
    return p.name
}

func (p *Product) GetId() int {
    return p.id
}

const fooId = 1                 // Product Foo's id
const barId = 2                 // Product Bar's id

type Foo struct {
    Product
    x int                       // Foo's internal data
}

type Bar struct {
    Product
    y int                       // Bar's internal data
}

type SameProducts map[int]IProduct
type Products map[int]SameProducts

func AllFoos(data Products) []*Foo {
    objs, ok := data[fooId]
    if !ok {
        return nil
    }

    foos := make([]*Foo, len(objs))

    i := 0
    for _, obj := range objs {
        if obj, ok := obj.(*Foo); ok {
            foos[i] = obj
            i++
        }
    }

    return foos
}

func AllBars(data Products) []*Bar {
    objs, ok := data[barId]
    if !ok {
        return nil
    }

    bars := make([]*Bar, len(objs))

    i := 0
    for _, obj := range objs {
        if obj, ok := obj.(*Bar); ok {
            bars[i] = obj
            i++
        }
    }

    return bars
}

func main() {
    // data是两层映射：第一层是产品ID到同类型产品的映射，第二层是单个产品的映射
    data := Products{}

    foo := Foo {
        Product: Product {
            name: "foo1",
                id: fooId,
            },
            x: 100,
        }

    foo2 := Foo {
        Product: Product {
            name: "foo2",
                id: fooId,
            },
            x: 101,
    }

    bar := Bar {
        Product: Product {
            name: "bar1",
                id: barId,
            },
            y: 200,
        }

    fooMap := data[fooId]
    if fooMap == nil {
        fooMap = SameProducts{}
    }
    fooMap[foo.x] = &foo
    fooMap[foo2.x] = &foo2
    data[fooId] = fooMap

    barMap := data[barId]
    if barMap == nil {
        barMap = SameProducts{}
    }
    barMap[bar.y] = &bar
    data[barId] = barMap

    // 提取并打印所有Foo和Bar类型产品
    
    foos := AllFoos(data)
    for _, obj := range foos {
        fmt.Printf("%v\n", obj)
    }

    bars := AllBars(data)
    for _, obj := range bars {
        fmt.Printf("%v\n", obj)
    }
}

// 运行输出：
// &{{foo1 1} 100}
// &{{foo2 1} 101}
// &{{bar1 2} 200}

解决方案 #

方法一：使用Go泛型（Go 1.18+ 推荐） #

Go 1.18引入泛型后，可直接编写通用的类型提取函数，彻底消除重复代码。定义泛型函数时指定目标类型参数，搭配产品ID即可实现通用逻辑：

// AllProducts 通用提取函数，T为目标类型，需实现IProduct接口
func AllProducts[T IProduct](data Products, productId int) []T {
    objs, ok := data[productId]
    if !ok {
        return nil
    }

    result := make([]T, 0, len(objs))
    for _, obj := range objs {
        if tObj, ok := obj.(T); ok {
            result = append(result, tObj)
        }
    }
    return result
}

使用时只需指定目标类型参数：

func main() {
    // ... 原有数据填充代码 ...

    foos := AllProducts[*Foo](data, fooId)
    for _, obj := range foos {
        fmt.Printf("%v\n", obj)
    }

    bars := AllProducts[*Bar](data, barId)
    for _, obj := range bars {
        fmt.Printf("%v\n", obj)
    }
}

该方案类型安全，编译时即可检查类型转换合法性，代码简洁，新增类型时无需编写重复函数。

方法二：使用反射（兼容Go 1.18之前版本） #

若项目使用旧版本Go，可通过反射实现通用提取，但会带来一定性能开销，且类型检查延迟到运行时：

import "reflect"

// AllProductsReflect 通过反射提取指定类型的切片
func AllProductsReflect(data Products, productId int, targetType reflect.Type) interface{} {
    objs, ok := data[productId]
    if !ok {
        return reflect.Zero(reflect.SliceOf(targetType)).Interface()
    }

    slice := reflect.MakeSlice(reflect.SliceOf(targetType), 0, len(objs))
    for _, obj := range objs {
        if reflect.TypeOf(obj) == targetType {
            slice = reflect.Append(slice, reflect.ValueOf(obj))
        }
    }
    return slice.Interface()
}

使用时需传入目标类型的reflect.Type：

func main() {
    // ... 原有数据填充代码 ...

    foos := AllProductsReflect(data, fooId, reflect.TypeOf(&Foo{})).([]*Foo)
    for _, obj := range foos {
        fmt.Printf("%v\n", obj)
    }

    bars := AllProductsReflect(data, barId, reflect.TypeOf(&Bar{})).([]*Bar)
    for _, obj := range bars {
        fmt.Printf("%v\n", obj)
    }
}

总结 #

优先选择泛型方案，它兼具类型安全与代码简洁性，是Go 1.18+解决此类问题的标准方式。反射方案仅作为旧版本Go的兼容选项，需注意运行时类型转换风险和性能损耗。

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