反射-结构体
这是我们反射四讲的第二讲，本次给大家讲解如何使用反射处理结构体。
使用反射如何输出结构体的字段名字和值,使用反射如何给结构体字段设置值。
为了确保反射输出所有的字段名字和值，关键在于一点只有 Kind == Struct 的才有。
注意： 指针类型是没有的！
前提考虑：
- 输入的是不是指针，会不会是多重指针。
- 输入的会不会是数组 Or 切片等非法内容。
- 结构体字段会不会是结构体。
- 结构体内部字段是否可见（简单来说就是作用域的问题，反射可以拿到私有的字段类型，但是拿不到值）。
查看值
获取结构体所有的字段和字段值：
func IterateFields(val any) (map[string]any, error) {
// 判断是否为nil
if val == nil {
return nil, errors.New("不能为nil")
}
// 获取类型
tpe := reflect.TypeOf(val)
// 获取值
refVal := reflect.ValueOf(val)
// 判断是否为指针，并且处理指针
for tpe.Kind() == reflect.Ptr {
tpe = tpe.Elem()
refVal = refVal.Elem()
}
// 结构体取值
numField := tpe.NumField()
res := make(map[string]any, numField)
for i := 0; i < numField; i++ {
fdType := tpe.Field(i)
res[fdType.Name] = refVal.Field(i).Interface()
}
return res, nil
}
测试：
type User struct {
Name string
Age int
}
func TestIterateFields(t *testing.T) {
user := &User{Name: "yxc", Age: 18}
u := &user
testcases := []struct {
name string
// 输入
val any
// 输出
wantRes map[string]any
wantErr error
}{
{
name: "测试nil",
val: nil,
wantErr: errors.New("不能为nil"),
},
{
name: "测试一级指针",
val: &User{Name: "yxc", Age: 18},
wantRes: map[string]any{
"Name": "yxc",
"Age": 18,
},
},
{
name: "测试多级指针",
val: u,
wantRes: map[string]any{
"Name": "yxc",
"Age": 18,
},
},
{
name: "测试结构体",
val: User{Name: "yxc", Age: 18},
wantRes: map[string]any{
"Name": "yxc",
"Age": 18,
},
},
}
for _, tt := range testcases {
t.Run(tt.name, func(t *testing.T) {
res, err := IterateFields(tt.val)
if err != nil {
return
}
assert.Equal(t, res, tt.wantRes)
})
}
}
设置值
当想要给结构体字段设置值的时候，我们一定要先检查字段的 CanSet。
简单来说，必须使用结构体指针，那么结构体的字段才是可以修改的。
当然指针指向的对象也是可以修改的。
func SetField(entity any, fieldName string, value any) error {
val := reflect.ValueOf(entity)
typ := val.Type()
// 只能是一级指针
if typ.Kind() != reflect.Ptr || typ.Elem().Kind() != reflect.Struct {
return errors.New("非法类型")
}
typ = typ.Elem()
val = val.Elem()
fd := val.FieldByName(fieldName)
if _, found := typ.FieldByName(fieldName); !found {
return errors.New("字段不存在")
}
if !fd.CanSet() {
return errors.New("字段不可设置")
}
fd.Set(reflect.ValueOf(value))
return nil
}
测试：
type PrivateUser struct {
name string
}
func TestSetField(t *testing.T) {
u1 := &User{Name: "yxc", Age: 18}
testcases := []struct {
name string
field string
entity any
newVal any
wantErr error
}{
{
name: "结构体",
entity: User{},
field: "Name",
wantErr: errors.New("非法类型"),
},
{
name: "private 字段",
entity: &PrivateUser{},
field: "name",
wantErr: errors.New("字段不可设置"),
},
{
name: "多级指针",
entity: &u1,
field: "Name",
wantErr: errors.New("非法类型"),
},
{
name: "非法字段",
entity: &User{},
field: "invalid_field",
wantErr: errors.New("字段不存在"),
},
{
name: "正常",
entity: &User{
Name: "yxc",
Age: 18,
},
field: "Name",
newVal: "ypb",
},
}
for _, tt := range testcases {
t.Run(tt.name, func(t *testing.T) {
err := SetField(tt.entity, tt.field, tt.newVal)
assert.Equal(t, tt.wantErr, err)
})
}
}
改进查看值
- 增加对于解指针后结构体的判断
- 增加私有字段的零值设置
func IterateFields(val any) (map[string]any, error) {
// 判断是否为nil
if val == nil {
return nil, errors.New("不能为nil")
}
// 获取类型
tpe := reflect.TypeOf(val)
// 获取值
refVal := reflect.ValueOf(val)
// 判断是否为指针，并且处理指针
for tpe.Kind() == reflect.Ptr {
tpe = tpe.Elem()
refVal = refVal.Elem()
}
// 确保是结构体
if tpe.Kind() != reflect.Struct {
return nil, errors.New("传入的值必须是结构体类型")
}
// 结构体取值
numField := tpe.NumField()
res := make(map[string]any, numField)
for i := 0; i < numField; i++ {
fdType := tpe.Field(i)
if fdType.IsExported() {
res[fdType.Name] = refVal.Field(i).Interface()
} else {
res[fdType.Name] = reflect.Zero(fdType.Type).Interface()
}
}
return res, nil
}
测试：
func TestZeroValue(t *testing.T) {
type UserV1 struct {
Name string
age int
}
user := &UserV1{Name: "ypb", age: 19}
num := &[]int{1}
testCases := []struct {
name string
input any
wantRes map[string]any
wantErr error
}{
{
name: "私有字段",
input: user,
wantRes: map[string]any{
"Name": "ypb",
"age": 0,
},
wantErr: nil,
},
{
name: "多重指针非法字段",
input: &num,
wantRes: nil,
wantErr: errors.New("传入的值必须是结构体类型"),
},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
res, err := IterateFields(tc.input)
assert.Equal(t, tc.wantErr, err)
if err != nil {
return
}
assert.Equal(t, tc.wantRes, res)
})
}
}
指针与指向指针的结构体关系
总结
在使用反射的去操纵结构体数据的时候，我们应该非常清楚对于指针的判断，以及如何解指针。
并且实际的开发过程中，应该注意测试的覆盖率。不然很容易引起 panic。
