经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置:技术经验 » 程序设计 » Go语言 » 查看文章
go语言reflect包最佳实践之struct操作(遍历、赋值与方法调用)
来源:cnblogs  作者:lwjj  时间:2020/11/9 16:09:45  对本文有异议

go语言reflect包最佳实践之struct操作(遍历、赋值与方法调用)

1. 反射基本概念

反射是指在程序运行期对程序本身进行访问和修改的能力。程序在编译时,变量被转换为内存地址,变量名不会被编译器写入到可执行部分。在运行程序时,程序无法获取自身的信息。
支持反射的语言可以在程序编译期将变量的反射信息,如字段名称、类型信息、结构体信息等整合到可执行文件中,并给程序提供接口访问反射信息,这样就可以在程序运行期获取类型的反射信息,并且有能力修改它们。
Go程序在运行期使用reflect包访问程序的反射信息。

golang中的接口值是两字节的数据结构,两个字节各是一个指针,其中:

  • 第一个指针指向一个叫做iTable的内部表,表中包含两方面内容,一是值的类型信息,二是值的方法集
  • 第二个指针指向实际存储的值。

对应地,任意接口值在go反射中都分为reflect.Type和reflect.Value两部分,我们可分别通过reflect.TypeOf()和reflect.ValueOf()函数对象的Type和Value。

本文将使用reflect包对结构体进行遍历、赋值与方法调用操作,以熟悉了解reflect包的基本概念与使用。

2. struct字段的遍历

2.1 简单结构体的遍历

首先定义一个如下的简单结构体,如程序所示,共有三个字段。

type Employee struct {
	Name   string
	Role   string
	Salary float64
}

下面,我们尝试用reflect包对一个Employee类型的值进行遍历,要求输出字段的名称、类型和值。

var xiaowang = &Employee{
	Name:   "xiaowang",
	Role:   "glory engineer",
	Salary: 0.5,
}

func traverse(target interface{}) {
	sVal := reflect.ValueOf(target)
	sType := reflect.TypeOf(target)
	if sType.Kind() == reflect.Ptr {
        //用Elem()获得实际的value
		sVal = sVal.Elem()
		sType = sType.Elem()
	}
	num := sVal.NumField()
	for i := 0; i < num; i++ {
		f := sType.Field(i)
		val := sVal.Field(i).Interface()
		fmt.Printf("%5s %v = %v\n", f.Name, f.Type, val)
	}
}

func main() {
	traverse(xiaowang)
}

需要注意的是,程序在正式遍历字段前,对种类(Kind)为指针(reflect.Ptr)的值调用了Elem()方法,令其指向实际的值。

(而事实上,reflect.Value.NumField()与reflect.Value.Field()等方法均需要调用者的种类(Kind)为结构体(reflect.Struct),否则程序会panic。)

运行程序,输出如下,可见已成功遍历了结构体的各字段

Name string = xiaowang
Role string = glory engineer
Salary float64 = 0.5

2.2 复杂结构体的遍历

考虑字段类型为结构体的特殊情况,比如

type ComplexStruct struct {
	CField1 string
	CField2 *SimpleStruct
	CField3 []string
}

我们需要将程序简单修改为递归遍历的结构,如下所示

var ComplexTarget = &ComplexStruct{
	CField1: "CValue1",
	CField2: SimpleTarget,
	CField3: []string{"CValue3", "sadf"},
}

func traverse2(target interface{}) {
	sVal := reflect.ValueOf(target)
	sType := reflect.TypeOf(target)
	if sType.Kind() == reflect.Ptr {
		sVal = sVal.Elem()
		sType = sType.Elem()
	}
	num := sVal.NumField()
	for i := 0; i < num; i++ {
        //判断字段是否为结构体类型,或者是否为指向结构体的指针类型
		if sVal.Field(i).Kind() == reflect.Struct || (sVal.Field(i).Kind() == reflect.Ptr && sVal.Field(i).Elem().Kind() == reflect.Struct) {
			traverse2(sVal.Field(i).Interface())
		} else {
			f := sType.Field(i)
			val := sVal.Field(i).Interface()
			fmt.Printf("%5s %v = %v\n", f.Name, f.Type, val)
		}
	}
}

func main() {
	traverse2(ComplexTarget)
}

每次访问字段都先判断其是否为结构体类型,或者是否为指向结构体的指针类型,若是则递归调用递归方法,否则直接输出访问结果即可。

运行程序,可得如下输出,可见已实现了期望的递归遍历的功能。

TeamName string = urTeam
Name string = xiaowang
Role string = glory engineer
Salary float64 = 0.5
Duty []string = [code debug]

3. struct赋值操作(根据map构建新struct)

给定一个map值,我们根据该map提供的信息,恢复构建出一个Employee类型的值

var employeeData = map[string]interface{}{
	"name":   "laozhang",
	"role":   "annother glory engineer",
	"salary": 1.5,
}

针对employeeData中key与结构体中字段名大小写不一致的问题,我们在Employee结构体定义中,给字段加入一些tag信息。(由于map信息往往由外部给出,其key不一定满足go的字段命名习惯,故直接修改字段名的方法来达到两者一致是不合适的。)

type Employee struct {
	Name   string  `key:"name"`
	Role   string  `key:"role"`
	Salary float64 `key:"salary"`
}

在对结构体对象赋值过程中,需要注意两方面的内容:

  1. 用reflect.Value.Set()方法给对应字段赋值,注意该方法的传入参数是reflect.Value类型的
  2. 在给字段赋值前需要进行类型检查,若map中的value和字段类型一致,则可以直接调用Set()方法赋值;若两者类型不一致,则需调用reflect.Type.ConvertibleTo()方法来判断是否可以进行类型转换,若可转换则调用reflect.Value.Convert()方法转换传参类型,倘若不可转换而强行调用Convert()方法,会导致程序panic。为了简便起见,若类型不可转换,我们在程序中同样返回panic并给出错误信息。
func rebuiltStruct(mapData map[string]interface{}, target interface{}) {
	sVal := reflect.ValueOf(target)
	sType := reflect.TypeOf(target)
	if sType.Kind() == reflect.Ptr {
		sVal = sVal.Elem()
		sType = sType.Elem()
	}
	num := sVal.NumField()
	for i := 0; i < num; i++ {
		f := sType.Field(i)
		val := sVal.Field(i)
		key := f.Tag.Get("key")
		if dataVal, ok := mapData[key]; ok {
			//类型判断与转换
			dataType := reflect.TypeOf(dataVal)
			fieldType := val.Type()
			if dataType == fieldType {
				val.Set(reflect.ValueOf(dataVal))
			} else {
				if dataType.ConvertibleTo(fieldType) {
					val.Set(reflect.ValueOf(dataVal).Convert(fieldType))
				} else {
                    panic(fmt.Sprintf("failed to convert from %s to %s \n", dataType, fieldType))
				}
			}
		} else {
			fmt.Printf("key %s not found in struct definition! \n", key)
		}
	}
	traverse2(target)
}
func main() {
	rebuiltStruct(employeeData, &Employee{})
}

运行上述程序,可得输出如下

Name string = laozhang
Role string = annother glory engineer
Salary float64 = 1.5

4. 调用struct的方法

4.1 方法遍历与无参调用

首先,我们对Employee结构体增加两个方法:

func (e Employee) Code() {
	fmt.Printf("I like to code \n")
}

func (e Employee) Debug() {
	fmt.Printf("I dislike to debug \n")
}

func (e Employee) raiseSalary() {
    fmt.Printf("I want to raise my salasy \n")
}

接着我们编写程序,用reflect遍历调用两个方法:

func callMethodWithReflect(x interface{}) {
	t := reflect.TypeOf(x).Elem()
	v := reflect.ValueOf(x).Elem()
	if t.Kind() == reflect.Ptr {
		v = v.Elem()
		t = t.Elem()
	}
	//NumMethod()只会计算导出的方法,即首字母大写的方法
	numOfMethod := v.NumMethod()
	fmt.Printf("We have %v methods. \n", numOfMethod)

	//以索引的方式遍历调用所有的方法
	for i := 0; i < numOfMethod; i++ {
		methodName := t.Method(i).Name
		methodType := t.Method(i).Type
		//方法的Type也可以用v.Method(i).Type()获得
		fmt.Printf("method-%v name is %s \n", i, methodName)
		fmt.Printf("method-%v type is %s \n", i, methodType)
		args := []reflect.Value{} //不含参调用
		v.Method(i).Call(args)
	}
}

运行程序可得如下结果,发现程序只调用了Code()和Debug(),忽略了raiseSalary()方法。这是因为reflect.Value.NumMethod()只能发现导出(首字母大写)的方法,而reflect.Type.Method()也只能访问到导出的方法。

需要注意的是,reflect.Type.Method()方法返回的仍是一个reflect.Value类型的值,只不过其Kind为Func。在调用方法时,reflect.Value.Call()方法的入参是一个reflect.Value的切片,且若Call()方法的调用者的Kind不是Func种类,程序会panic。

We have 2 methods.
method-0 name is Code 
method-0 type is func(main.Employee) 
I like to code 
method-1 name is Debug 
method-1 type is func(main.Employee) 
I dislike to debug 

因此若修改方法raiseSalary()为导出方法,

func (e Employee) RaiseSalary() {
    fmt.Printf("I want to raise my salary \n")
}

再重新执行程序可以发现三个方法均已被遍历到

We have 3 methods. 
...
...
method-2 name is RaiseSalary 
method-2 type is func(main.Employee) 
I want to raise my salary 

4.2 按方法名调用

我们再增加一个含参数方法

func (e Employee) Work(i int) {
	fmt.Printf("I work for %v hours per day. \n", i)
}

下面,通过指定方法名的方法调用它

func callByMethodName(x interface{}) {
	t := reflect.TypeOf(x).Elem()
	v := reflect.ValueOf(x).Elem()
	if t.Kind() == reflect.Ptr {
		v = v.Elem()
		t = t.Elem()
	}

	//通过方法名调用指定方法,这里同样无法调用未导出的方法
    printMethod := v.MethodByName("Work")
    
	//此处需注意判断Zero Value
	if printMethod.IsValid() {
		args := []reflect.Value{reflect.ValueOf(10)}
		printMethod.Call(args)
	} else {
		fmt.Printf("method not found!")
	}
}

这里需要注意以下容易踩坑的地方:

  1. reflect.Value.MethodByName()同样只能访问到导出了的方法,若传入了未导出的方法名,方法会返回一个零值(Zero Value),而不会报错
  2. 若直接对零值(Zero Value)调用Call()方法,程序会panic,故在调用Call()之前需验证返回值是否为零值。
  3. 验证一个值是否是零值(Zero Value),千万不可以用isZero()方法,否则程序会panic。这是因为零值不是IsZero方法返回true的值,而是IsValid方法返回false的值。在golang文档中,有如下说明:"The zero Value represents no value. Its IsValid method returns false, its Kind method returns Invalid, its String method returns "", and all other methods panic." 即,零值的IsValid方法返回false,其Kind方法返回Invalid,其String方法返回"",对零值的任何其他方法的调用均会导致panic

参考链接

原文链接:http://www.cnblogs.com/liweijiee/p/13879163.html

 友情链接:直通硅谷  直通硅谷 怎么样 mac软件下载