上一篇文章中我们说了go语言的接口以及底层的实现,大家对其褒贬不一,那么我们今天再继续说一下go语言的反射,看看go语言的反射能不能给程序员带来快乐(反射反射,程序员的快乐)。

首先我们知道go语言的变量,其包括两部分,一个为类型(type),一个为值(value),我们回想一下接口的具体实现,其内部也是两部分,即value的指针和type的指针。type 包括 static type和concrete type. 简单来说 static type是你在编码是看见的类型(如int、string),concrete type是runtime系统看见的类型。还有一个就是断言,变量类型断言是否成功,要根据runtime类型来决定,也就是看其是否实现了某些或者某个方法。

我们使用反射主要是在处理函数的参数为 interface{} 类型,在运行时确定参数的具体类型,例如slice、func等。接下来我们看一个例子:

package main
import "fmt"
func main() {
 a := []string{"a"}// string slice
 TestFunc(a)
}
// TestFunc param of interface test
func TestFunc(in []interface{}) {
 fmt.Println(in)
}

首先告诉大家,这里面是编译不过的:Cannot use 'a' (type []string) as type []interface{}

大家可能会想,这是典型的泛型的使用啊。其实大家再仔细看一看,我们知道slice中所有元素都是同一个类型的,而且slice也是一个类型,所以,上面的代码中,编译器会认为[]string{"a"} 是 interface 类型,而传入的是[]interface{},所以编译不过。当然改进的办法有很多,我们写一个简单的改进代码:

package main
import "fmt"
func main() {
 a := []string{"a"} // string slice
 TestFunc(a)
}
// TestFunc param of interface test
func TestFunc(in interface{}) {// 这里我们将参数从 []interface{} 改为 interface{}
 fmt.Println(in)
}

这样就可以了,也说明了上面我说的是正确的。接下来我们就使用反射来做一些小示例:

package main
import (
 "fmt"
 "reflect"
)
func main() {
 a := []string{"a"} // string slice
 TestFunc(a)
}
// TestFunc param of interface test
func TestFunc(in interface{}) {
 fmt.Println("参数的 type :", reflect.TypeOf(in))
 fmt.Println("参数的 value:", reflect.ValueOf(in))
}

其结果如下图片:

说完go语言的interface再说说反射

运行结果

也就是说我们可以明确的知道出入进来的参数的类型和值,其实就是去根据 iface struct(上一篇interface中讨论过)中的两个指针去获取结果。除此之外,我们还可以传入struct以及func类型,对于struct我们可以获取其struct的类型以及各个字段的值,也可以获取其拥有的方法。

package main
import (
 "fmt"
 "reflect"
)
func main() {
 s := Student{
 Name: "Bob",
 Age: 18,
 }
 TestFunc(s)
}
// TestFunc param of interface test
func TestFunc(in interface{}) {
 rt := reflect.TypeOf(in)
 rf := reflect.ValueOf(in)
 fmt.Println("参数的类型:", rt)
 fmt.Println("参数的值:", rf)

 //遍历字段获取名字与值
 for i := 0; i < rt.NumField(); i++ {
 field := rt.Field(i)
 value := rf.Field(i).Interface()
 fmt.Printf("%s: %v = %v
", field.Name, field.Type, value)
 }
 // 遍历方法
 for i := 0; i < rt.NumMethod(); i++ {
 m := rt.Method(i)
 fmt.Printf("%s: %v
", m.Name, m.Type)
 }
 }
 type Student struct {
 Name string
 Age int
 }

 // 这里大家需要注意,如果 receiver 是指针类型(func (this *Student))这种形式,反射是找不到这个方法的。
 func (this Student) GetName() {
 fmt.Println(this.Name)
 }

说完go语言的interface再说说反射

struct使用reflect运行结果

接下来我们再写一个典型的对于参数的 func 类型的使用反射的例子:

package main
import (
 "fmt"
 "reflect"
)
func main() {
 s := Student{
 Name: "Bob",
 Age: 18,
 }
 TestFunc(s)
}
// TestFunc param of interface test
func TestFunc(in interface{}) {
 // 首先通过反射获取参数具体内容
 rv := reflect.ValueOf(in)
 // 构造参数
 args := []reflect.Value{reflect.ValueOf("noodles")}
 // 根据方面名字获取方法并调用
 rv.MethodByName("Eat").Call(args)
 // 调用无参的方法可以传入nil或者空的slice
 rv.MethodByName("Hello").Call(nil)
}
type Student struct {
 Name string
 Age int
}
func (this Student) Hello() {
 fmt.Println(this.Name, "hello!")
}
func (this Student) Eat(food string) {
 fmt.Println(this.Name, "like", food)
}

说完go语言的interface再说说反射

func 类型使用反射调用

到这里我们反射的基本使用算是告一段落,总结起来,不过是对于不知类型的具体处理,其实如果能不用反射还是不要用的,毕竟会影响性能的,首先在运行时做这些处理,go语言的GC肯定会有些影响,还有就是在反射过程中肯定用到很多的枚举,就拿类型来说,判断其具体类型肯定会for循环形式的判断的。我们笨一点想,一些东西在编译时就做好的和在运行时做,肯定不一样的。但是话说回来,有些地方还是要用的。我个人认为,想不到其他办法时我们就用反射试一下吧。

反射的功能不止如此,我们还可以为其赋值等等操作,这里就不在一一说明了,大家这么聪明遇到时肯定比我写的好。最后说一下go的反射三定律:

1.反射可以将“接口类型变量”转换为“反射类型对象”。

2.反射可以将“反射类型对象”转换为“接口类型变量”。

3.如果要修改“反射类型对象”,其值必须是“可写的”(settable)。

个人建议:实践是检验真理的唯一标准。所以希望大家动手敲才能更好的理解。

如果对你有帮助,欢迎点赞转载。

后续会有更多的模式和算法以及区块链相关的,如果你是想学习go语言或者是对设计模式或者算法感兴趣亦或是区块链开发工作者,都可以关注一下。(微信公众号:Go语言之美,更多go语言知识信息等)。公众号会持续为大家分享更多干货。