Go-反射

反射

常用包而已：strings 、strconv、time、math、reflect、io、os、rutime

正常的开发，很少用到。因为效率低。

开发一些脚手架，自动实现一些底层的判断。

interface{} = any，由于这种动态类型是不确定的，我们可能在底层代码进行判断，从而选择使用什么来处理。

---

反射机制可以在程序运行的过程中，获取到信息（变量：类型、值。结构体：字段、方法）

我们可以通过反射来修改变量和值、通过反射来调用方法。

reflect 包所有的方法几乎都在这里面

• reflect.Type类型typeOf reflect .Value值valueof()
• var age int = 18
• var 变量名 变量类型 = 变量值
• var user User = User{xx，xx}

类型：Type （在编程中我们使用Type），指代的是某一种类型

种类：Kind（反射更多时候用Kind来区分），指代的是相似的一些列类型

package main

import (
   "fmt"
   "reflect"
)

// 反射
/*
Type : reflect.TypeOf(a) , 获取变量的类型
Value ：reflect.ValueOf(a) ， 获取变量的值
*/

func main() {
   // 正常编程定义变量
   var a int = 3
   fmt.Println("type", reflect.TypeOf(a))
   fmt.Println("value", reflect.ValueOf(a))

   // 根据反射的值，来获取对象对应的类型和数值
   // 如果我们不知道这个对象的信息，我们可以通过这个对象拿到代码中的一切。
   // Value
   v := reflect.ValueOf(a) // string int User
   // Kind : 获取这个值的种类， 在反射中，所有数据类型判断都是使用种类。
   if v.Kind() == reflect.Float64 {
      fmt.Println(v.Float())
   }
   if v.Kind() == reflect.Int {
      fmt.Println(v.Int())
   }
   fmt.Println(v.Kind() == reflect.Float64)
   //fmt.Println(v.Type())

}

静态类型 & 动态类型

在反射过程中，编译的时候就知道变量类型的就是静态类型、如果在运行时候才知道类型的就是动态类型

静态类型：变量在声明时候给他赋予类型的

var name string // string是静态类型的
var age int  // int 是静态类型的

动态类型：在运行的时候可能发生变化，主要考虑赋值问题

var A interface{}   // interface{} 静态类型 

A = 10              // interface{} 静态类型   动态类型 int
A = "xuexiangban"   // interface{} 静态类型   动态类型 string

为什么要用反射：

1、我们需要编写一个函数，但是不知道函数传递给我的参数时什么？没约定好，传入的类型太多，这些类型不能统一表示，反射

2、我们在某些使用，需要根据条件来判断具体使用哪个函数处理问题，根据用户的输入来决定，这时候就需要对函数的参数进行反射，在运行期间来动态处理。

为什么不建议使用反射：

1、和反射相关的代码，不方便阅读，开发中，代码可读性（指标）很重要

2、Go语言是静态类型的语言，编译器可以找出开发时候的错误，如果代码中有大量反射代码，随时可能存在安全问题，panic，项目就终止

3、反射的性能很低，相对于正常的开发，至少慢2-3个数量级。项目关键位置低耗时，一定是不能使用反射的。更多时候使用约定。

反射获取变量信息

实现拿到一个对象，还原它的本身结构信息

reflect.TypeOf(v) : 获取变量的类型 Type

• Type.kind , 找到种类
• Type.NumField()，找到里面字段的数量
  • Type.Filed(i)
• Type.NumMethod()，找到里面方法的数量
  • Type.Method(i)

reflect.ValueOf(v) : 获取变量的值 Value

• Value.Field(i).Interface()

package main

import (
   "fmt"
   "reflect"
)

type User struct {
   Name string
   Age  int
   Sex  string
}

func (user User) Say(msg string) {
   fmt.Println("User 说：", msg)
}

// toString : 打印结构体信息
func (user User) PrintInfo() {
   fmt.Printf("姓名：%s，年龄：%d，性别：%s\n", user.Name, user.Age, user.Sex)
}

func main() {
   user := User{"kuangshen", 18, "男"}

   reflectGetInfo(user)
}

// 通过反射，获取变量的信息
func reflectGetInfo(v interface{}) {
   // 1、获取参数的类型Type , 可能是用户自己定义的，但是Kind一定是内部类型struct
   getType := reflect.TypeOf(v)
   fmt.Println(getType.Name()) // 类型信息 User
   fmt.Println(getType.Kind()) // 找到上级的种类Kind  struct

   // 2、获取值
   getValue := reflect.ValueOf(v)
   fmt.Println("获取到value", getValue)

   // 获取字段，通过Type扒出字段
   // Type.NumField() 获取这个类型中有几个字段  3
   // field(index) 得到字段的值
   for i := 0; i < getType.NumField(); i++ {
      field := getType.Field(i)              // 类型
      value := getValue.Field(i).Interface() // value
      // 打印
      fmt.Printf("字段名：%s,字段类型：%s，字段值：%v\n", field.Name, field.Type, value)
   }

   // 获取这个结构体的方法 , 获取方法的数量
   for i := 0; i < getType.NumMethod(); i++ {
      method := getType.Method(i)
      fmt.Printf("方法的名字：%s,方法类型：%s", method.Name, method.Type)
   }

}
/*
type User struct{
   Name string
   Age int
   Sex string
}
func (main.User) PrintInfo(){}
func (main.User) Say(string)
*/

反射修改变量的值

vaule.CanSet

vaule.SetXXX

package main

import (
   "fmt"
   "reflect"
)

// 反射设置变量的值
func main() {

   var num float64 = 3.14
   update(num)
   fmt.Println(num)

}
func update(v any) {
   // 通过反射修改值,需要操作对象的指针，拿到地址，然后拿到指针对象
   pointer := reflect.ValueOf(&v)
   newValue := pointer.Elem()

   fmt.Println("类型：", newValue.Type())
   fmt.Println("判断该类型是否可以修改：", newValue.CanSet())
   if newValue.Kind() == reflect.Float64 {
      // 通过反射对象给变量赋值
      newValue.SetFloat(2.21)
   }
   if newValue.Kind() == reflect.Int {
      // 通过反射对象给变量赋值
      newValue.SetFloat(2)
   }
}

修改结构体变量：通过属性名，来实现修改

func main() {
	user := User{"kuangshen", 18, "男"}

	value := reflect.ValueOf(&user)
	if value.Kind() == reflect.Ptr {
		// 获取指针对象
		newValue := value.Elem()
		if newValue.CanSet() {
			// 如果是结构体：1、需要找到对象的结构体字段名
			newValue.FieldByName("Name").SetString("狂神")
			newValue.FieldByName("Age").SetInt(26)
		}
	}

	fmt.Println(user)

	//reflectGetInfo(user)
}

反射调用方法

value.MethodByName(“PrintInfo”).Call(nil)

// 参数构建

args := make([]reflect.Value, 1)
args[0] = reflect.ValueOf(“这反射来调用的”)

通过反射调用user方法

user := User{"kuangshen", 18, "男"}

// 通过方法名，找到这个方法, 然后调用 Call() 方法来执行
// 反射调用方法
value := reflect.ValueOf(user)
fmt.Printf("kind:%s,type:%s\n", value.Kind(), value.Type())
value.MethodByName("PrintInfo").Call(nil) // 无参方法调用

// 有参方法调用
args := make([]reflect.Value, 1)
args[0] = reflect.ValueOf("这反射来调用的")
value.MethodByName("Say").Call(args) // 无参方法调用

反射调用函数

package main

import (
   "fmt"
   "reflect"
)

// 反射调用函数  func
func main() {
   // 通过函数名来进行反射
   // Kind func
   value1 := reflect.ValueOf(fun1)
   fmt.Println(value1.Kind(), value1.Type())
   value1.Call(nil)

   value2 := reflect.ValueOf(fun2)
   fmt.Println(value2.Kind(), value2.Type())

   args1 := make([]reflect.Value, 2)
   args1[0] = reflect.ValueOf(1)
   args1[1] = reflect.ValueOf("hahahhaha")
   value2.Call(args1)

   vuale3 := reflect.ValueOf(fun3)
   fmt.Println(vuale3.Kind(), vuale3.Type())
   args2 := make([]reflect.Value, 2)
   args2[0] = reflect.ValueOf(1)
   args2[1] = reflect.ValueOf("hahahhaha")
   resultValue := vuale3.Call(args2)
   fmt.Println("返回值：", resultValue)
}
func fun1() {
   fmt.Println("fun1:无参")
}
func fun2(i int, s string) {
   fmt.Println("fun2:有参 i=", i, " s=", s)
}
func fun3(i int, s string) string {
   fmt.Println("fun3:有参有返回值 i=", i, " s=", s)
   return s
}