在Go语言的反射机制中，我们可以通过reflect包操作运行时对象类型信息，获取结构体字段的底层值并完成类型断言是反射使用的高频场景，常见于通用序列化、配置解析、ORM框架开发等场景。
反射获取结构体字段的基础准备
Go语言的反射核心围绕两个类型展开：reflect.Type和reflect.Value。reflect.Type用于描述变量的静态类型信息，reflect.Value用于存储变量的实际值。操作结构体字段时，首先需要获取结构体的reflect.Value实例，注意传入的必须是指针类型才能修改值，或者传入值类型仅做读取操作。
我们可以通过reflect.ValueOf()函数获取任意变量的reflect.Value，如果传入的是结构体指针，需要先调用Elem()方法获取指针指向的实际结构体值：
package main
import (
"fmt"
"reflect"
)
// 定义测试用的结构体
type User struct {
Name string
Age int
Score float64
}
func main() {
u := User{
Name: "张三",
Age: 20,
Score: 95.5,
}
// 获取结构体的reflect.Value，这里传入值类型
val := reflect.ValueOf(u)
fmt.Println("结构体值的reflect.Value类型：", val.Type())
}
获取结构体字段的底层值
获取结构体字段值有两种常用方式，一种是通过字段索引，另一种是通过字段名称。
通过字段索引获取
结构体的字段在反射中是有序的，我们可以通过Field(i int)方法传入字段索引获取对应字段的reflect.Value，索引从0开始，对应结构体定义中字段的顺序：
func main() {
u := User{
Name: "张三",
Age: 20,
Score: 95.5,
}
val := reflect.ValueOf(u)
// 获取第一个字段（Name）的reflect.Value
nameField := val.Field(0)
fmt.Println("Name字段的底层值：", nameField.Interface())
// 获取第二个字段（Age）的reflect.Value
ageField := val.Field(1)
fmt.Println("Age字段的底层值：", ageField.Interface())
}
通过字段名称获取
更常用的方式是通过FieldByName(name string)方法传入字段名称获取对应字段的reflect.Value，这种方式不需要关心字段的定义顺序，可读性更强：
func main() {
u := User{
Name: "张三",
Age: 20,
Score: 95.5,
}
val := reflect.ValueOf(u)
// 通过字段名获取Score字段
scoreField := val.FieldByName("Score")
if scoreField.IsValid() {
fmt.Println("Score字段的底层值：", scoreField.Interface())
} else {
fmt.Println("未找到Score字段")
}
}
注意调用FieldByName后最好通过IsValid()方法判断字段是否存在，避免获取不存在的字段导致后续操作出错。
对底层值进行类型断言
通过reflect.Value的Interface()方法可以获取字段的底层值，返回值是interface{}类型，此时我们可以通过类型断言将其转换为对应的具体类型。
基础类型断言示例
针对不同类型的字段，我们可以分别进行类型断言：
func main() {
u := User{
Name: "张三",
Age: 20,
Score: 95.5,
}
val := reflect.ValueOf(u)
// 处理Name字段，类型为string
nameField := val.FieldByName("Name")
if nameField.IsValid() {
nameVal, ok := nameField.Interface().(string)
if ok {
fmt.Printf("Name字段值：%s，类型：stringn", nameVal)
}
}
// 处理Age字段，类型为int
ageField := val.FieldByName("Age")
if ageField.IsValid() {
ageVal, ok := ageField.Interface().(int)
if ok {
fmt.Printf("Age字段值：%d，类型：intn", ageVal)
}
}
// 处理Score字段，类型为float64
scoreField := val.FieldByName("Score")
if scoreField.IsValid() {
scoreVal, ok := scoreField.Interface().(float64)
if ok {
fmt.Printf("Score字段值：%.1f，类型：float64n", scoreVal)
}
}
}
动态判断类型再断言
如果不确定字段的具体类型，可以先通过reflect.Value的Kind()方法获取字段的基础类型，再对应进行类型断言：
func main() {
u := User{
Name: "张三",
Age: 20,
Score: 95.5,
}
val := reflect.ValueOf(u)
// 遍历所有字段
for i := 0; i < val.NumField(); i++ {
field := val.Field(i)
fieldName := val.Type().Field(i).Name
// 判断字段的基础类型
switch field.Kind() {
case reflect.String:
val, ok := field.Interface().(string)
if ok {
fmt.Printf("字段%s是string类型，值为：%sn", fieldName, val)
}
case reflect.Int:
val, ok := field.Interface().(int)
if ok {
fmt.Printf("字段%s是int类型，值为：%dn", fieldName, val)
}
case reflect.Float64:
val, ok := field.Interface().(float64)
if ok {
fmt.Printf("字段%s是float64类型，值为：%.1fn", fieldName, val)
}
default:
fmt.Printf("字段%s是未知类型n", fieldName)
}
}
}
注意事项和常见错误
- 如果要通过反射修改结构体字段的值，传入
reflect.ValueOf的必须是结构体指针，并且需要先调用Elem()获取指针指向的值，否则会触发panic。 - 类型断言的类型必须和字段的实际类型完全匹配，比如字段是
int类型，断言成int64会失败，因为Kind()返回的是reflect.Int，和reflect.Int64是不同的类型。 - 如果字段是私有字段（首字母小写），反射可以读取其值，但无法修改，修改时会触发panic。
- 调用
Interface()方法前最好确认字段是有效值，避免对零值reflect.Value调用该方法导致错误。
完整示例代码
package main
import (
"fmt"
"reflect"
)
type User struct {
Name string
Age int
Score float64
}
func main() {
u := User{
Name: "张三",
Age: 20,
Score: 95.5,
}
// 获取结构体值的reflect.Value
val := reflect.ValueOf(u)
// 如果是要修改值，需要传入指针：val := reflect.ValueOf(&u).Elem()
fmt.Println("===== 按字段名获取并断言 =====")
// 按字段名获取并断言
nameField := val.FieldByName("Name")
if nameField.IsValid() {
if name, ok := nameField.Interface().(string); ok {
fmt.Println("Name:", name)
}
}
ageField := val.FieldByName("Age")
if ageField.IsValid() {
if age, ok := ageField.Interface().(int); ok {
fmt.Println("Age:", age)
}
}
scoreField := val.FieldByName("Score")
if scoreField.IsValid() {
if score, ok := scoreField.Interface().(float64); ok {
fmt.Println("Score:", score)
}
}
fmt.Println("n===== 遍历所有字段动态断言 =====")
for i := 0; i < val.NumField(); i++ {
field := val.Field(i)
fieldName := val.Type().Field(i).Name
switch field.Kind() {
case reflect.String:
fmt.Printf("%s: %v (string)n", fieldName, field.Interface())
case reflect.Int:
fmt.Printf("%s: %v (int)n", fieldName, field.Interface())
case reflect.Float64:
fmt.Printf("%s: %v (float64)n", fieldName, field.Interface())
}
}
}