Golang reflect 反射机制核心操作详解：取值、赋值与类型推断

顾言

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

原创

利用 Golang 的 reflect 包，开发者可以在运行时检查结构体属性、读取字段值，并通过指针安全地执行动态赋值。本文详细介绍了 TypeOf 和 ValueOf 的使用区别，以及如何结合 struct tag 实现 Map 到结构体的自动映射。

准备条件

在使用反射时，需明确区分静态类型信息与运行时实例状态。reflect.TypeOf 用于获取变量的类型信息（如字段名、类型），而 reflect.ValueOf 则直接关联变量实例的值。此外，若需通过反射修改结构体内部的字段值，必须传递该结构体的指针地址，否则反射操作无法寻址并引发 panic。

获取字段信息（名称与类型）

首先定义一个包含标签的结构体，以便后续测试：

type User struct {
	UserName string
	UserId   int `name:"uid"`
}

初始化其实例：

u := User{"octoboy", 101}

第 1 步：处理类型对象

通过 reflect.TypeOf 获取类型信息。注意：如果传入的是指针变量（如 &User{...}），需要先判断其 Kind 是否为指针，并使用 Elem() 解开指针以获取实际指向的类型：

t := reflect.TypeOf(u)
if t.Kind() == reflect.Ptr {
    t = t.Elem()
}

第 2 步：遍历结构体字段

使用循环遍历所有字段，提取字段的名称：

for i := 0; i < t.NumField(); i++ {
    fmt.Println(t.Field(i).Name)
}

输出结果：
UserName
UserId

读取与展示字段的值

要获取结构体内具体的变量值及其类型，应使用 reflect.ValueOf：

v := reflect.ValueOf(u)
if v.Kind() == reflect.Ptr {
    v = v.Elem()
}

读取字段值

调用 Interface() 可返回字段的实际值（返回值为 interface{}），或者根据具体类型调用 Int() / String()：

for i := 0; i < v.NumField(); i++ {
    fmt.Println(v.Field(i).Interface())
}

输出结果：
octoboy
101

读取字段类型

在 Value 中，类型信息通过 Kind() 提供：

for i := 0; i < v.NumField(); i++ {
    fmt.Println(v.Field(i).Kind())
}

输出结果：
string
int

设置字段值（动态赋值）

此阶段必须传入结构体的指针，以便后续的 Set 方法能够修改内存中的实际数据。

静态类型赋值

假设需要修改结构体属性，获取可变值的引用：

va := reflect.ValueOf(&u)
if va.Kind() == reflect.Ptr { // 取指针指向的内容
    va = va.Elem()
    for i := 0; i < va.NumField(); i++ {
        // 字符串赋值
        if va.Field(i).Kind() == reflect.String {
            va.Field(i).SetString("new_name")
        }
        // Int 类型统一赋值
        if va.Field(i).Kind() == reflect.Int {
            va.Field(i).Set(reflect.ValueOf(99))
        }
    }
}

接口切片动态赋值

当已知字段顺序且数据源为切片时，可以通过匹配 Kind 进行批量赋值：

values := []interface{}{"octoboy", 123}
for i := 0; i < va.NumField(); i++ {
    if reflect.ValueOf(values[i]).Kind() == va.Field(i).Kind() {
        va.Field(i).Set(reflect.ValueOf(values[i]))
    }
}

Map 转结构体（进阶用法）

这是 ORM 框架或反序列化底层最常用的逻辑：将无序的 Map 映射到有序的结构体字段上。这里提供了两种键查找策略：一是直接匹配字段名，二是使用 struct tag。

func MapToStruct(m map[string]interface{}, str interface{}) {
    val := reflect.ValueOf(str)
    if val.Kind() != reflect.Ptr { // 必须是普通指针
        panic(any("must be ptr!"))
    }
    val = val.Elem()
    if val.Kind() != reflect.Struct { // 指针指向的必须是结构体
        panic(any("must be struct"))
    }

    for i := 0; i < val.NumField(); i++ {
        // 优先使用 Tag 里的 Key (例如 name:"uid") 作为 Map 的查找键
        // 如果没有 Tag 配置，默认使用 Field Name
        name := val.Type().Field(i).Tag.Get("name")
        if name == "" {
            name = val.Type().Field(i).Name
        }

        if v, ok := m[name]; ok { // Map 中存在对应的 key
            // 校验数据类型是否一致，防止 Set 引发 Panic
            if reflect.ValueOf(v).Kind() == val.Field(i).Kind() {
                val.Field(i).Set(reflect.ValueOf(v))
            }
        }
    }
}