Go反射四讲---第二讲：反射与结构体，使用反射如何操纵结构体？

反射-结构体

这是我们反射四讲的第二讲，本次给大家讲解如何使用反射处理结构体。

使用反射如何输出结构体的字段名字和值,使用反射如何给结构体字段设置值。

为了确保反射输出所有的字段名字和值，关键在于一点只有 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。