平时编写 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() 则沿着这个地址找到原变量本身,两者的指向关系如下图所示。

在修改变量之前,我们先调用 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 序列化、数据库字段映射这类底层组件依然离不开反射。
不过,反射需要在运行期间动态解析类型,执行速度比普通代码慢。而且它缺少编译阶段的类型检查,写错了只有运行到那一行才会报错。因此小伙伴们平时写业务代码时,只要能用普通接口或泛型解决的问题,优先采用常规写法就可以了。
