Go——反射基本概念

超、凢脫俗 2023-10-09 21:28 15阅读 0赞

### 1、基本数据结果和入口函数 ###

##### reflect.Type #####

反射包里面有一个通用的描述类型公共信息的结构type,这个rtype实际上和接口内部实现时的runtime包里面的type是同一个东西，只是因为包的隔离性分开定义而已，都是描述类型的通用信息，同时为每一种基础类型封装了一个特定的结构。示例如下：

type rtype struct {
        
    	size       uintptr
    	ptrdata    uintptr  // number of bytes in the type that can contain pointers
    	hash       uint32   // hash of type; avoids computation in hash tables
    	tflag      tflag    // extra type information flags
    	align      uint8    // alignment of variable with this type
    	fieldAlign uint8    // alignment of struct field with this type
    	kind       uint8    // enumeration for C
    	alg        *typeAlg // algorithm table
    	gcdata     *byte    // garbage collection data
    	str        nameOff  // string form
    	ptrToThis  typeOff  // type for pointer to this type, may be zero
    }
    
    //数组类型
    type arrayType struct {
        
    	rtype `reflect:"array"`
    	elem  *rtype // array element type
    	slice *rtype // slice type
    	len   uintptr
    }
    
    //指针类型
    // ptrType represents a pointer type.
    type ptrType struct {
        
    	rtype `reflect:"ptr"`
    	elem  *rtype // pointer element (pointed at) type
    }

rtype实现了接口relfect.Type,Go的refelct包通过函数refelct.Typeof()返回一个Type类型的接口，使用者通过接口来获取对象的类型信息。

为什么反射接口返回的是一个Type接口类型，而不是直接返回type？原因很简单，一是因为类型信息是一个只读的信息，不可能动态地修改类型的相关信息，那太不安全了；二是因为不同的类型，类型定义也不一样，使用接口这一抽象数据结构能够进行统一的抽象。所以refelct包通过reflect.TypeOf()函数返回一个Type的接口变量，通过接口抽象出来的方法访问具体类型的信息。

reflect.TypeOf()的函数原型如下：

func Typeof(i interface())Type

形参是一个空接口类型，返回值是一个Type接口类型。  
reflect.Type接口的主要方法：

1.  所有类型通用的方法。示例如下：

//返回包含包名的类型名字，对于未命名类型返回的是空
    Name() string
    
    //Kind返回该类型的底层基础类型
    Kind() Kind
    
    //确定当前类型是否实现了u接口类型，注意这里的u必须是接口类型的Type
    Implements(u Type) bool
    
    //判断当前类型的实例是否能够赋值给type为u的类型变量
    AssignableTo(u Type) bool
    
    //判断当前类型的实例是否能强制类型转换为u类型变量
    ConvertibleTo(u Type) bool
    
    //判断当前类型是否支持比较（等于或不等于）
    Comparable() bool
    
    //返回一个类型的方法个数
    NumMethod() int
    
    //通过索引值访问方法，索引值必须属于[0, NumMethod()]，否则引发panic
    Method(int) Method
    
    //通过方法名获取Method
    MethodByName(string) (Method, bool)
    
    //返回类型的包路径，如果类型是预声明类型或未命名类型，则返回空字符串
    PkgPath() string
    
    //返回存放该类型的实例需要多大的字节空间
    Size() uintptr

1.  不同基础类型的专有方法。  
    这些方法是某种类型特有的，如果不是某种特定类型却调用了该类型的方法，则会引发panic。所以为了避免panic,在调用特定类型的专有方法前，要清楚地知道该类型是什么，如果不确定类型，则要先调用Kind()方法确定类型后再调用类型的专有方法。示例如下：

//Int*, Uint*, Float*, Complex*: Bits
    //Array: Elem, Len
    //Chan: ChanDir, Elem
    //Func: In, NumIn, Out, NumOut, IsVariadic
    //Map: Key, Elem
    //Ptr: Elem
    //Slice: Elem
    //Struct: Field, FieldByIndex, FieldByName, FieldByNameFunc, NumField
    
    //返回类型的元素信息，该方法只适合Array、Chan、Map、Ptr、Slice类型
    Elem() Type
    
    //返回数值型类型内存占用的位数
    Bits() int
    
    //struct类型专用的方法
    //返回字段数目
    NumField() int
    //通过整数索引获取struct字段
    Field(i int) StructField
    //获取嵌入字段获取struct字段
    FieldByIndex(index []int) StructField
    //通过名字查找获取struct字段
    FieldByName(name string) (StructField, bool)
    FieldByNameFunc(match func(string) bool) (StructField, bool)
    
    //func类型专用方法
    //函数是否不定参数函数
    IsVariadic() bool
    //输入参数个数
    NumIn() int
    //返回值个数
    NumOut() int
    //返回第i个返回值类型
    Out(i int) Type
    
    //map类型专用方法
    //返回map key的type
    Key() Type

下面通过一个具体的示例来看一下reflect.Type()的基本功能：

package main
    
    import (
    	"fmt"
    	"reflect"
    )
    
    func main() {
        
    	s := Student{
        }
    	rt := reflect.TypeOf(s)
    	fieldName, ok := rt.FieldByName("Name")
    
    	//取tag数据
    	if ok {
        
    		fmt.Println(fieldName.Tag)
    	}
    	fieldAge, ok2 := rt.FieldByName("Age")
    	//可以像JSON一样，取tag里的数据，多个tag之间无逗号，tag不需要引号
    	if ok2 {
        
    		fmt.Println(fieldAge.Tag.Get("a"))
    		fmt.Println(fieldAge.Tag.Get("b"))
    	}
    
    	fmt.Println("type_Name:", rt.Name())
    	fmt.Println("type_NumField:", rt.NumField())
    	fmt.Println("type_PkgPath:", rt.PkgPath())
    	fmt.Println("type_String:", rt.String())
    	fmt.Println("type.Kind.String:", rt.Kind().String())
    	fmt.Println("type.String()=", rt.String())
    
    	//获取结构类型的字段名称
    	for i := 0; i < rt.NumField(); i++ {
        
    		fmt.Printf("type.Field[%d].Name:=%v\n", i, rt.Field(i).Name)
    	}
    
    	sc := make([]int, 10)
    	sc = append(sc, 1, 2, 3)
    	sct := reflect.TypeOf(sc)
    
    	//获取slice元素的type
    	scet := sct.Elem()
    
    	fmt.Println("slice element type.Kind()=", scet.Kind())
    	fmt.Printf("slice element type.Kind()=%d\n", scet.Kind())
    	fmt.Println("slice element type.String()=", scet.String())
    	fmt.Println("slice element type.Name()=", scet.Name())
    	fmt.Println("slice element type.NumMethod()=", scet.NumMethod())
    	fmt.Println("slice element type.PkgPath()=", scet.PkgPath())
    	fmt.Println("slice element type.PkgPath()=", sct.PkgPath())
    }
    
    type Student struct {
        
    	Name string "学生姓名"
    	Age  int    `a:"1111"b:"3333"`
    }
    
    
    //结果
    学生姓名
    1111
    3333
    type_Name: Student
    type_NumField: 2
    type_PkgPath: main
    type_String: main.Student
    type.Kind.String: struct
    type.String()= main.Student
    type.Field[0].Name:=Name
    type.Field[1].Name:=Age
    slice element type.Kind()= int
    slice element type.Kind()=2
    slice element type.String()= int
    slice element type.Name()= int
    slice element type.NumMethod()= 0
    slice element type.PkgPath()= 
    slice element type.PkgPath()=

对于ref1ect.Type0f(a),传进去的实参a有两种类型，一种是接口变量，另一种具体类型变量。如果a是具体类型变量，则reflect.TypeOf()返回的是具体的类型信息；如果a是一个  
接口变量，则函数的返回结果又分两种情况：如果a绑定了具体类型实例，则返回的是接口的动态类型，也就是a绑定的具体实例类型的信息，如果没有绑定具体类型实例，则返回的是接口自身的静态类型信息。下面以一个示例来看一下这种特性。

package main
    
    import (
    	"fmt"
    	"reflect"
    )
    
    func main() {
        
    	var a INT = 12
    	var b int = 14
    
    	//实参是具体类型，reflect.TypeOf()返回是其静态类型
    	ta := reflect.TypeOf(a)
    	tb := reflect.TypeOf(b)
    	fmt.Println(ta.Name()) //INT
    	fmt.Println(tb.Name()) //int
    
    	//INT和int是两个类型，二者不相等
    	if ta == tb {
        
    		println("ta==tb")
    	} else {
        
    		println("ta!=tb") //ta!=tb
    	}
    
    	//底层基础类型
    	println(ta.Kind().String()) //int
    	println(tb.Kind().String()) //int
    
    	s1 := A{
        1}
    	s2 := B{
        "tata"}
    
    	//实参是具体类型，reflect.TypeOf()返回的是其静态类型
    	println(reflect.TypeOf(s1).Name()) //A
    	println(reflect.TypeOf(s2).Name()) //B
    
    	//Type的Kind()方法返回的是基础类型，类型A和B的底层基础类型都是struct
    	println(reflect.TypeOf(s1).Kind().String()) //struct
    	println(reflect.TypeOf(s2).Kind().String()) //struct
    
    	ita := new(Ita)
    	var itb Ita = s2
    
    	//实参是未绑定具体变量的接口类型，reflect.TypeOf()返回的是接口本身
    	//也就是接口的静态类型
    	println(reflect.TypeOf(ita).Elem().Name())          //Ita
    	println(reflect.TypeOf(ita).Elem().Kind().String()) //interface
    
    	//实参是绑定了具体变量的接口类型，reflect.TypeOf()返回的是绑定的具体类型
    	//也就是接口的动态类型
    	println(reflect.TypeOf(itb).Name())          //B
    	println(reflect.TypeOf(itb).Kind().String()) //struct
    }
    
    type INT int
    
    type A struct {
        
    	a int
    }
    
    type B struct {
        
    	b string
    }
    
    type Ita interface {
        
    	String() string
    }
    
    func (b B) String() string {
        
    	return b.b
    }

##### reflect.Value #####

reflect.Value表示实例的值信息，reflect.Value是一个struct,并提供了一系列的method给使用者。先来看一下Value的基本数据结构：

type Value struct {
        
    	typ *rtype
    
    	ptr unsafe.Pointer
    
    	flag
    }

refelct.Value总共有三个字段，一个是值的类型指针typ,另一个是指向值的指针ptr,最后一个是标记字段flag反射包中通过reflect.ValueOf()函数获取实例的值信息

reflect.ValueOf()的原型如下：

func ValueOf(i interface{
        }) Value

输入参数是空接口，输出是一个Value类型的变量。Value本身提供了丰富的API给用户使用。先来看一个简单示例。

package main
    
    import (
    	"fmt"
    	"reflect"
    )
    
    func main() {
        
    	u := User{
        1, "Tom", 30}
    	Info(u)
    }
    
    type User struct {
        
    	Id   int
    	Name string
    	Age  int
    }
    
    func (this User) string() {
        
    	println("User:", this.Id, this.Name, this.Age)
    }
    
    func Info(o interface{
        }) {
        
    	//获取Value信息
    	v := reflect.ValueOf(o)
    
    	//通过Value获取Type
    	t := v.Type()
    
    	//类型名称
    	println("Type:", t.Name())
    
    	//访问接口字段名、字段类型和字段信息
    	println("Fields:")
    	for i := 0; i < t.NumField(); i++ {
        
    		field := t.Field(i)
    		value := v.Field(i).Interface()
    
    		//类型查询
    		switch value := value.(type) {
        
    		case int:
    			fmt.Printf(" %6s: %v = %d\n", field.Name, field.Type, value)
    		case string:
    			fmt.Printf(" %6s: %v = %s\n", field.Name, field.Type, value)
    		default:
    			fmt.Printf(" %6s: %v = %s\n", field.Name, field.Type, value)
    		}
    	}
    }
    
    //结果
    Type: User
    Fields:
         Id: int = 1
       Name: string = Tom
        Age: int = 30

### 2、基础类型 ###

Type接口有一个Kind()方法，返回的是一个整数枚举值，不同的值代表不同的类型。这里的类型是一个抽象的概念，我们暂且称之为“基础类型”，比如所有的结构都归结为一种基础类型struct,所有的函数都归结为一种基础类型func。基础类型是根据编译器、运行时构建类型的内部数据结构不同来划分的，不同的基础类型，其构建的最终内部数据结构不一样。

Go的具体类型可以定义成千上万种，单单一个struct就可以定义出很多新类型，但是它们都归结为一种基础类型struct。基础类型是抽象的，其种类有限。Go总共定义了26种基础类型，具体如下：

//Kind用来表示特定的类型，每个枚举值都代表一种类型
    type Kind uint
    
    const (
    	Invalid Kind = iota
    	Bool
    	Int
    	Int8
    	Int16
    	Int32
    	Int64
    	Uint
    	Uint8
    	Uint16
    	Uint32
    	Uint64
    	Uintptr
    	Float32
    	Float64
    	Complex64
    	Complex128
    	Array
    	Chan
    	Func
    	Interface
    	Map
    	Ptr
    	Slice
    	String
    	Struct
    	UnsafePointer
    )

##### 底层类型和基础类型 #####

底层类型和基础类型的区别在于，基础类型是抽象的类型划分，底层类型是针对每一个具体的类型来定义的，比如不同的struct类型在基础类型上都划归为sturct类型，但不同的struct底层类型是不一样的。示例如下：

type A struct {
        
    	a int
    }
    
    type Aa A
    
    type B struct {
        
    	b int
    }
    
    //A、Aa、B的基础类型都是struct，B的底层类型是其自身，A和Aa的底层类型都是A

### 3、类型汇总 ###

简单类型 复合类型 类型字面量 自定义类型
    命名类型 未命名类型
    接口类型 具体类型
    底层类型 基础类型
    动态类型 静态类型

Go的类型看似很复杂，其实Go的类型非常精炼，这些类型概念之间的关系如图所示。  
![在这里插入图片描述][96f85b1884b9428eb1b0a119fb5a85d3.png]

[96f85b1884b9428eb1b0a119fb5a85d3.png]: https://img-blog.csdnimg.cn/96f85b1884b9428eb1b0a119fb5a85d3.png