Go 反射

平时编写 Go 代码时,变量是什么类型、结构体里有哪些字段,在编译阶段就已经确定下来了。即使函数接收的是 any 空接口参数,只要可能出现的类型是已知的,我们也可以通过前面学过的类型断言来判断处理。

但如果我们要编写一个通用函数,在写代码时根本不知道传入的结构体里有哪些字段,这时应该怎么办呢?Go 语言在标准库中提供了 reflect 包来实现 “反射(Reflection)”。小伙伴们可以把反射看作程序运行时的 “透视镜”。借助它,我们可以在运行期间动态查看变量的类型、值和标签,甚至直接修改变量的值。

获取变量的类型与值

在 Go 语言中,使用反射前需要先导入标准库 reflect 包。反射最基础的操作有 2 个:① 调用 reflect.TypeOf() 获取变量的类型信息;② 调用 reflect.ValueOf() 获取变量的值信息。

语法:

t := reflect.TypeOf(x)
v := reflect.ValueOf(x)

说明:

这两个函数的参数类型都是空接口 any,因此我们可以直接传入任意类型的变量 x。

其中,reflect.TypeOf(x) 返回一个 reflect.Type 接口,用来表示 “它是什么类型”。而 reflect.ValueOf(x) 返回一个 reflect.Value 结构体,用来表示 “它里面保存的值是多少”。

示例 1:查看变量的类型与值

package main

import (
    "fmt"
    "reflect"
)

func main() {
    x := 100

    t := reflect.TypeOf(x)     // 获取类型信息
    v := reflect.ValueOf(x)    // 获取值信息

    fmt.Println("t =", t)
    fmt.Println("v =", v)

    num := v.Int() + 50        // 取出整数值参与运算
    fmt.Println("num =", num)
}

运行结果如下。

t = int
v = 100
num = 150

分析:

reflect.TypeOf(x) 表示获取变量 x 的类型信息 int,而 reflect.ValueOf(x) 则拿到了里面保存的数值 100。

需要注意的是,v 本身是一个 reflect.Value 结构体,就像一个装着数字的包装盒,我们不能直接拿它去和普通整数相加。想要取出里面的整数参与运算,就得先调用 v.Int() 方法拆出真实数值。

这里要留意一个小细节:v.Int() 统一返回 int64 类型。上面代码写 v.Int() + 50 之所以能正常编译,是因为数字 50 属于无类型常量,编译器会自动把它当成 int64 处理。

如果后续我们要拿 v.Int() 和普通 int 变量相加,就必须先用 int(v.Int()) 做类型转换。至于字符串或浮点数,我们可以分别调用 v.String() 或 v.Float() 取出。

在调用这些取值方法时,必须与变量的真实类型保持一致。如果变量里保存的是字符串,我们却强行调用 v.Int(),程序在运行期间就会触发 panic 报错。

除了查看具体的类型名称之外,遇到自定义类型时,我们还经常需要判断它底层到底是基本类型还是结构体。这时就要区分 reflect.Type 的 Name() 和 Kind() 两个方法,下面我们来看一个例子。

示例 2:区分 Name() 与 Kind()

package main

import (
    "fmt"
    "reflect"
)

type MyInt int

type Student struct {
    Name string
}

func main() {
    var a MyInt = 10
    t1 := reflect.TypeOf(a)
    fmt.Println("t1 Name =", t1.Name(), "Kind =", t1.Kind())

    stu := Student{Name: "Lucy"}
    t2 := reflect.TypeOf(stu)
    fmt.Println("t2 Name =", t2.Name(), "Kind =", t2.Kind())
}

运行结果如下。

t1 Name = MyInt Kind = int
t2 Name = Student Kind = struct

分析:

在这个例子中,MyInt 是基于 int 定义的自定义类型,Student 是我们定义的结构体类型。调用 Name() 得到的是具体名称 MyInt 和 Student,而调用 Kind()(意为 “种类”)得到的则是它在底层的所属分类 int 和 struct。

对于这两个方法的区别,小伙伴们只需要记住一句话:Name() 看的是表面的 “具体名字”,而 Kind() 看的是底层的 “基础分类”。哪怕程序里定义了 Student、Book 等十几个不同的结构体,它们的 Name() 各不相同,但底层的分类全都是结构体。

当我们在代码中判断底层分类时,可以将 Kind() 的返回值与 reflect 包提供的常量进行比较,比如写成 t2.Kind() == reflect.Struct。

此外,像切片 []int 或指针 *int 这类没有单独命名的复合类型,调用 Name() 会返回空字符串 "",而 Kind() 依然能准确识别出 slice 或 ptr。

如何通过反射修改变量的值?

前面我们只是使用反射来 “读取” 变量的信息。如果想要通过反射 “修改” 原变量的值,就不能直接把变量本身传给 reflect.ValueOf(),而必须先传入变量的指针 &x,再调用 .Elem() 方法找到指针指向的目标变量。

语法:

v := reflect.ValueOf(&x).Elem()
v.SetInt(新整数值)

说明:

Elem 是英文 “element(元素)” 的缩写。你可以把反射里的 .Elem() 看作指针前面的解引用星号(*):&x 负责取出变量的地址,而 .Elem() 则沿着这个地址找到原变量本身,两者的指向关系如下图所示。

reflect.ValueOf(&x) 与 Elem() 的指向关系

在修改变量之前,我们先调用 v.CanSet() 方法检查该变量是否允许修改,返回 true 就代表可以修改。确认无误后,再根据变量类型调用 SetInt()、SetString()、SetFloat() 或 SetBool() 写入新值。

示例 3:通过反射修改变量值

package main

import (
    "fmt"
    "reflect"
)

func main() {
    x := 10

    v := reflect.ValueOf(&x).Elem()    // 传入指针并解引用
    if v.CanSet() {
        v.SetInt(99)                   // 修改原变量的值
    }

    fmt.Println("x =", x)
}

运行结果如下。

x = 99

分析:

v := reflect.ValueOf(&x).Elem() 这一句代码把两个步骤连在了一起写。对于这个例子来说,上面代码等价于下面两步。

ptrVal := reflect.ValueOf(&x)    // 获取指针的反射对象
v := ptrVal.Elem()               // 取出指向的原变量

拿到原变量 x 对应的反射对象 v 并通过 v.CanSet() 检查后,调用 v.SetInt(99) 就会把原变量 x 的值修改为 99。

可能有些小伙伴会问:“为什么一定要传 &x 并调用 .Elem(),直接传 x 不行吗?” 我们可以对比一下下面这两种写法。

// 正确方式
v1 := reflect.ValueOf(&x).Elem()
v1.SetInt(99)

// 错误方式
v2 := reflect.ValueOf(x)
v2.SetInt(99)

在 Go 语言中,函数传参全部采用值传递,直接写 reflect.ValueOf(x) 时传入的只是 x 的一份副本。修改副本并不会影响外面的原变量,所以 v2.CanSet() 会返回 false,强行调用 v2.SetInt(99) 就会触发 panic 报错。

同样地,如果我们只传了 &x 却漏写 .Elem(),拿到的就只是指针变量本身的副本,它的 CanSet() 同样为 false。只有调用 .Elem() 找到指针指向的目标变量后,才能真正修改 x 的值。

反射操作结构体

在定义结构体时,我们经常会在字段后面的反引号里写上结构体标签,比如 json:"book_title"。这些标签本身不会影响结构体的日常读写,它们其实就是专门留给反射在运行期间读取的。

1. 遍历结构体字段与读取标签

在运行期间遍历结构体字段并读取标签时,我们需要让类型对象 t(reflect.Type)和值对象 v(reflect.Value)配合使用,常用的方法有以下 4 个:

  • t.NumField():获取结构体中包含的字段总个数。
  • t.Field(i):从类型对象 t 中获取第 i 个字段的定义信息,包括字段名 field.Name、类型 field.Type 和标签 field.Tag。
  • field.Tag.Get("键名"):从字段标签中提取指定键名对应的值,比如提取 "json" 对应的字段名。
  • v.Field(i):从值对象 v 中获取第 i 个字段保存的实际数据值。

接下来,我们通过一个例子把结构体里的字段名、字段值和 JSON 标签全部读取出来。

示例 4:读取结构体字段与标签

package main

import (
    "fmt"
    "reflect"
)

type Book struct {
    Title string `json:"book_title"`
    Price int    `json:"book_price"`
}

func main() {
    b := Book{Title: "Go 入门", Price: 68}
    t := reflect.TypeOf(b)
    v := reflect.ValueOf(b)

    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)             // 获取字段定义信息
        value := v.Field(i)             // 获取字段实际值
        tag := field.Tag.Get("json")    // 读取 json 标签
        fmt.Printf("字段名:%s,值:%v,标签:%s\n", field.Name, value, tag)
    }
}

运行结果如下。

字段名:Title,值:Go 入门,标签:book_title
字段名:Price,值:68,标签:book_price

分析:

t.NumField() 返回了 Book 结构体的字段总个数 2。在循环内部,t.Field(i) 与 v.Field(i) 分别获取第 i 个字段的定义信息和实际值,再由 field.Tag.Get("json") 提取出反引号里的标签内容。

需要注意的是,只有当反射对象的底层分类是结构体(即 t.Kind() == reflect.Struct)时,才能调用 NumField() 方法。如果传入的是结构体指针 &b 却没有先调用 .Elem(),直接执行 NumField() 就会触发运行期 panic 报错。

在实际编写通用工具函数时,调用者既可能传结构体值,也可能传结构体指针。为了同时兼容这两种情况,我们通常会在遍历字段前先做一次指针判断与解引用,代码如下:

if t.Kind() == reflect.Ptr {
    t = t.Elem()
    v = v.Elem()
}

经过这几行判断之后,无论外面传进来的是 b 还是 &b,后面都可以安全地检查 t.Kind() == reflect.Struct 并遍历字段了。

看到这里,大家就能明白标准库里的 json.Marshal() 是怎么工作的了。当我们把结构体传给 json.Marshal(b) 时,它底层正是通过反射遍历各个字段,读出 field.Tag.Get("json") 作为键名,再把 v.Field(i) 的值拼装成 JSON 字符串的。

2. 按名称修改结构体字段

如果想要通过反射按名称找到并修改结构体里的某个字段,我们同样需要先传入结构体指针并调用 .Elem(),再使用 v.FieldByName() 找到目标字段并写入新值。

语法:

v := reflect.ValueOf(&结构体变量).Elem()
field := v.FieldByName("字段名")

说明:

v.FieldByName("字段名") 会在结构体中按名称查找指定字段,并返回对应的 reflect.Value 对象。如果传入的字段名在结构体中不存在,它会返回一个无效对象,此时调用 field.CanSet() 会返回 false。

示例 5:修改结构体字段的值

package main

import (
    "fmt"
    "reflect"
)

type Book struct {
    Title string
    Price int
}

func main() {
    b := Book{Title: "Go 入门", Price: 68}

    v := reflect.ValueOf(&b).Elem()    // 传入结构体指针并解引用
    priceField := v.FieldByName("Price")
    if priceField.CanSet() {
        priceField.SetInt(59)          // 修改 Price 字段的值
    }

    fmt.Printf("%+v\n", b)
}

运行结果如下。

{Title:Go 入门 Price:59}

分析:

v.FieldByName("Price") 表示在结构体中按名称查找 Price 字段。找到后,我们先通过 priceField.CanSet() 确认该字段存在且允许修改,再调用 priceField.SetInt(59) 将 b.Price 的值更新为 59。

注意:

  • 必须传入结构体指针并解引用:修改结构体字段时,我们传给 reflect.ValueOf() 的必须是结构体指针 &b,并通过 .Elem() 取出目标结构体,否则所有字段都无法修改。
  • 字段名首字母必须大写:只有首字母大写的公开字段(如 Title、Price)才允许通过反射修改。如果是首字母小写的私有字段(如 price),CanSet() 会返回 false,不能直接写入新值。

在实际项目开发中,我们平时编写普通业务逻辑很少需要手写复杂的反射代码。虽然前面学过的泛型也能编写通用函数,但泛型无法在运行期间动态遍历未知结构体的字段或读取标签,因此像 JSON 序列化、数据库字段映射这类底层组件依然离不开反射。

不过,反射需要在运行期间动态解析类型,执行速度比普通代码慢。而且它缺少编译阶段的类型检查,写错了只有运行到那一行才会报错。因此小伙伴们平时写业务代码时,只要能用普通接口或泛型解决的问题,优先采用常规写法就可以了。

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号