Golang泛型与反射实战详解

Cora

发布时间：2026-10-15| 6人浏览过

原创

本文详细介绍Golang中泛型（Generics）与反射（Reflection）的用法，包含泛型定义、类型约束、反射核心方法及操作结构体的完整步骤。

Golang 泛型的定义与应用

第1步：理解泛型核心价值

泛型主要用于解决数据类型抽象的问题，其生命周期仅在编译期。在没有泛型时，若要编写逻辑相同但处理不同数据类型的函数（如分别求和 int64 和 float64 类型的切片），必须编写多份重复代码。引入泛型后，只需定义一次逻辑，即可在不同数据类型间复用。

第2步：基础泛型方法定义

下面展示如何定义一个接受 map 并返回聚合值的泛型函数 SumIntsOrFloats。

// SumIntsOrFloats 定义泛型方法，接收任意可比较键[K]，值为 int64 或 float64 [V]
func SumIntsOrFloats[K comparable, V int64 | float64](m map[K]V) V {
    var s V
    for _, v := range m {
        s += v
    }
    return s
}

func main() {
	ints := make(map[string]int64)
	ints["name"] = 5
	ints["value"] = 6
	floats := make(map[string]float64)
	floats["name"] = 5.6
	floats["value"] = 6.5
    
	// 显式指定类型参数
	fmt.Printf("Generic sums: %v and %v\n", 
		SumIntsOrFloats[string, int64](ints), 
		SumIntsOrFloats[string, float64](floats))
    
	// 编译器可自动推导类型参数
	fmt.Printf("Generic sums (inferred): %v and %v\n", 
		SumIntsOrFloats(ints), 
		SumIntsOrFloats(floats))
}

第3步：自定义泛型类型约束

除了内置的 any（等同于 interface{}）和 comparable（支持相等/不等比较的类型），可以创建自定义接口作为类型约束：

// 自定义约束：仅允许 int64 和 float64
type Number interface {
    int64 | float64
}

func SumNumbers[K comparable, V Number](m map[K]V) V {
    // ... 遍历求和逻辑 ...
    return sum
}

注意：如果运行时报错，可能是 IDE 版本过低导致语法高亮异常，升级 IDEA 或 Go 插件即可解决，这不影响实际编译运行。

Golang 反射机制详解

第1步：理解反射的作用

反射使得程序在运行时能够“自省”（introspection）。即使编译时未知具体的类型信息，也能通过反射机制来修改变量的值、获取变量的类型及其结构布局、调用方法等。在 Golang 中，主要依赖 reflect 包的两个核心入口：

reflect.TypeOf(i interface{})：获取传入参数的类型对象（Type）。
reflect.ValueOf(i interface{})：获取传入参数的值对象（Value）。该方法可能使对象逃逸到堆空间。

第2步：结构体字段的读取与遍历

通过以下代码演示如何通过反射读取结构体实例的属性、标签（Tag）以及方法：

type Name struct {
    Name string `use:"Ok"`
}

func structReflect() {
    n := Name{Name: "这是反射结构"}
    typeOf := reflect.TypeOf(n)
    valueOf := reflect.ValueOf(n)
    
    // 打印类型和方法数
    fmt.Printf("类型名称：%s\n", typeOf.Name())
    methodNum := typeOf.NumMethod()
    fmt.Printf("获取到方法的数量：%d\n", methodNum)

    // 遍历所有方法
    for i := 0; i < methodNum; i++ {
        fmt.Printf("方法名：%v\n", typeOf.Method(i).Name)
    }

    // 读取结构体字段及其 Tag
    fieldNum := typeOf.NumField()
    for i := 0; i < fieldNum; i++ {
        field := typeOf.Field(i)
        if lookup, ok := field.Tag.Lookup("use"); ok {
            fmt.Printf("字段[%s]的use标签：%v\n", field.Name, lookup)
        }
    }
}

第3步：通过反射修改变量值与方法调用

若要通过反射修改结构体内部的值，必须对指针进行反射（即 &n），因为非地址不可直接写入：

func setValue() {
    n := Name{Name: "修改前"}
    // 必须取地址进行反射，否则是 Value 副本而非引用
    v := reflect.ValueOf(&n)
    v = v.Elem() // 解引用获取结构体本身

    // 1. 整体赋值
    newName := Name{Name: "新结构体值"}
    v.Set(reflect.ValueOf(newName))

    // 2. 设置特定字段
    fieldValue := v.FieldByName("Name")
    fieldValue.SetString("反射修改后的Name")

    // 3. 调用结构体方法
    methodName := "Show"
    method := v.MethodByName(methodName)
    method.Call(nil) // 无参调用
}

第4步：判断类型

利用 Kind() 方法判断变量属于何种底层数据结构，或在运行时做分支处理：

func judgeType() {
    n := Name{Name: "123"}
    t := reflect.TypeOf(n)
    switch t.Kind() {
    case reflect.Struct:
        fmt.Println("这是一个结构体")
    case reflect.Slice:
        fmt.Println("这是一个切片")
    }
}