通过reflect.TypeOf获取结构体类型元数据，可遍历字段名、类型、标签及嵌套结构。示例中User结构体包含基本类型、指针、切片和匿名字段，利用反射能动态解析其所有字段信息，适用于JSON序列化、ORM等运行时元编程场景。
很多时候，我们需要在运行时探究一个结构体的内部构造，比如它有哪些字段，这些字段都是什么类型。在Golang里，reflect包就是干这个的。简单来说，就是先用reflect.TypeOf拿到结构体的类型元数据，然后就能像翻字典一样，把里面的字段类型都摸清楚。
这事儿说起来简单，做起来也挺直观的，但里头有些小细节，稍不注意可能就会踩坑。核心思想就是通过reflect.TypeOf拿到一个值的“类型描述符”，然后从这个描述符里去挖它的字段信息。
比如我们有一个这样的结构体：
package main
import (
"fmt"
"reflect"
)
// Address 是一个嵌套结构体
type Address struct {
City string `json:"city"`
ZipCode int `json:"zip_code"`
}
// User 包含多种字段类型，包括基本类型、嵌套结构体、切片、指针和匿名字段
type User struct {
Name string `json:"name" validate:"required"`
Age int `json:"age"`
Email string `json:"email"`
Address Address `json:"address"`
Tags []string `json:"tags"`
Secret *string `json:"secret,omitempty"` // 指针类型
// 匿名字段，它本身也是一个类型，但其字段会被提升到User层面
ID string `json:"id"` // 这是一个匿名字段，等同于 struct { ID string }
}
func main() {
u := User{
Name: "张三",
Age: 30,
Email: "zhangsan@example.com",
Address: Address{
City: "北京",
ZipCode: 100000,
},
Tags: []string{"developer", "golang"},
ID: "user_123",
}
// 为了演示指针字段，我们给Secret赋值
secretVal := "my_secret_key"
u.Secret = &secretVal
// 获取User实例的类型。reflect.TypeOf会返回值的动态类型。
t := reflect.TypeOf(u)
// 如果传入的是指针，需要用Elem()解引用才能获取到实际结构体的类型信息。
// 比如：tPtr := reflect.TypeOf(&u)
// if tPtr.Kind() == reflect.Ptr {
// t = tPtr.Elem()
// }
// 确保我们处理的是结构体类型
if t.Kind() != reflect.Struct {
fmt.Printf("错误：传入的不是结构体类型，而是 %s\n", t.Kind())
return
}
fmt.Printf("结构体 %s 有 %d 个字段:\n", t.Name(), t.NumField())
// 遍历结构体的所有字段
for i := 0; i < t.NumField(); i++ {
field := t.Field(i) // field 是 reflect.StructField 类型
// field.Name: 字段名称 (如 "Name", "Age")
// field.Type.String(): 字段的完整类型字符串 (如 "string", "int", "main.Address", "[]string", "*string")
// field.Type.Kind(): 字段的基础种类 (如 reflect.String, reflect.Int, reflect.Struct, reflect.Slice, reflect.Ptr)
// field.Anonymous: 是否是匿名字段
// field.Tag: 字段的标签，可以通过 .Get("key") 获取特定标签值
fmt.Printf(" 字段名: %-8s | 类型: %-15s | Kind: %-8s | 匿名: %t | Tag(json): %s\n",
field.Name,
field.Type.String(),
field.Type.Kind(),
field.Anonymous,
field.Tag.Get("json"),
)
// 进一步处理复杂类型：嵌套结构体、切片、指针
if field.Type.Kind() == reflect.Struct && !field.Anonymous {
// 这是一个非匿名的嵌套结构体
fmt.Printf(" - 这是一个嵌套结构体 '%s'，其内部字段:\n", field.Type.Name())
for j := 0; j < field.Type.NumField(); j++ {
nestedField := field.Type.Field(j)
fmt.Printf(" 字段名: %-8s | 类型: %-10s | Kind: %-8s | Tag(json): %s\n",
nestedField.Name,
nestedField.Type.String(),
nestedField.Type.Kind(),
nestedField.Tag.Get("json"),
)
}
} else if field.Type.Kind() == reflect.Slice {
// 这是一个切片类型，通过 Elem() 获取其元素类型
fmt.Printf(" - 这是一个切片类型，元素类型是: %s (Kind: %s)\n",
field.Type.Elem().String(),
field.Type.Elem().Kind(),
)
} else if field.Type.Kind() == reflect.Ptr {
// 这是一个指针类型，通过 Elem() 获取其指向的元素类型
fmt.Printf(" - 这是一个指针类型，指向的元素类型是: %s (Kind: %s)\n",
field.Type.Elem().String(),
field.Type.Elem().Kind(),
)
}
}
}反射获取字段类型，这玩意儿在日常业务代码里可能不那么常见，但一旦用起来，它解决的问题往往是那些“硬编码”搞不定的。我个人觉得，它最亮眼的地方就在于运行时元编程的能力。
立即学习“go语言免费学习笔记（深入）”；
-
JSON/ORM库的魔力: 咱们平时用的
encoding/json包，或者各种ORM框架（比如GORM），它们在序列化/反序列化数据时，就需要知道一个结构体有哪些字段，每个字段是什么类型，有没有json:"name"这样的tag。反射就是它们实现这些功能的基石。没有反射，这些库就得为每种结构体写死处理逻辑，那简直是噩梦。 - 数据校验框架: 想象一下，你要写一个通用的数据校验器，比如检查一个`
