day15 反射

了解go的反射

• 反射：与 面向对象中的反射类似！
  • 程序运行中，获取到的信息（变量：类型，值。 结构体：字段，方法）
  • 可以通过反射机制，来改变变量和值
  • reflect 包， 实现反射
  • reflect.Type : 类型。 指示某一种类型
  • reflect.Value ： 值
  • reflect.Kind ： 种类。用于反射场景更多，指代的是相似的一些类型，当遇到自定义类型时，使用kind获取原始种类
• 为什么使用反射
  • 编写函数时，不知道函数传递的参数是什么类型。使用any接收一切参数，利用反射 reflect 识别数据类型，种类
  • 用户输入数据类型不清楚时，利用反射获取数据类型，种类。 程序运行期间动态处理

静态类型和动态类型

• 在反射过程中。程序编译的时候变量类型为静态类型，程序运行过程中变量是动态类型。
• 静态类型：
  • var name string // 静态类型
• 动态类型：
  • var A interface {} // 静态类型
  • A = 10 // interface 静态类型， 运行时属于动态类型 int
  • A = "abcd" // interface 静态类型， 运行时属于动态类型 string

反射使用

• 通过反射获取信息

package main

import (
	"fmt"
	"reflect"
)

type AType int
type User struct {
	name   string
	age    int
	sex    bool
	custom AType
}

// 必须是暴露出来的方法，小写的私有方法不被查看到
func (u User) Say(content string) {
	fmt.Printf("用户：%s 。 说：%s\n", u.name, content)
}
func (u User) GetInfo() {
	fmt.Printf("用户名：%s，用户年龄：%d，用户性别：%d", u.name, u.age, u.sex)
}
func analyticDataFunc(v interface{}) {
	// v 是一个任意变量
	// 1. 获取 v 的类型。 一般使用Kind，Type会被用户自定
	getType := reflect.TypeOf(v) // Type 类型
	fmt.Println("v type:", getType)

	// 1.1 . 通过vType 获取 v 的 名称
	vName := getType.Name()
	fmt.Println("v name:", vName)
	// 1.2 . 通过 vType 获取 Kind 的种类
	vKind := getType.Kind()
	fmt.Println("v kind:", vKind)

	// 2. 获取 v 变量中的值
	getValue := reflect.ValueOf(v)
	fmt.Println("v value:", getValue)

	// 2.1 遍历字段 和 具体的值:
	// getValue.NumField() 获取字段和值,该函数返回长度。非可遍历
	for index := 0; index < getValue.NumField(); index++ {
		vFieldName := getType.Field(index)    // 字段信息
		vFieldValue1 := getValue.Field(index) // 值
		fmt.Println("v变量包含的信息:", "字段：", vFieldName, "值：", vFieldValue1)
	}

	// 2.2 遍历方法
	// getType.NumMethod() 获取 大写开头的 暴露的出来的函数数量！
	for i := 0; i < getType.NumMethod(); i++ {
		method := getType.Method(i)
		fmt.Printf("method Name:【%s】 method Type：【%v】\n", method.Name, method.Type)
	}

}
func main() {

	/*
		反射场景
			- 通过反射获取信息
	*/

	var u = User{"张三", 3, true, 1000000}
	fmt.Println("define u data:", u)
	u.Say("你好")
	u.GetInfo()
	analyticDataFunc(u)
}

通过反射修改数据

• 通过反射修改值，需要操作对象的指针，拿到地址

package main

import (
	"fmt"
	"reflect"
)

func main() {
	/* 通过反射修改信息 */
	// 通过反射修改值，需要操作对象的指针，拿到地址
	var num = 3.14
	pointer := reflect.ValueOf(&num)
	newValue := pointer.Elem()            // 获取指针对象
	fmt.Println("类型：", newValue.Type()) // 使用 Kind()
	fmt.Println("判断该类型能否修改：", newValue.CanSet())
	newValue.SetFloat(2.11) // 通过反射修改数据
	fmt.Println("newValue:", newValue)

}

通过反射修改变量的函数

package main

import (
	"fmt"
	"reflect"
)

func reflectionModifiedVariableFunc(v any) reflect.Value {
	// 通过反射修改变量
	pointer := reflect.ValueOf(v) // 操作地址对象
	newValue := pointer.Elem()
	newValueType := newValue.Kind()
	fmt.Println("        [待修改变量] 值:", newValue)
	fmt.Println("        [待修改变量] 原类型:", newValueType)
	fmt.Println("        [待修改变量] 是否能修改:", newValue.CanSet())
	if newValueType == reflect.Int {
		newValue.SetInt(100)
	}

	if newValueType == reflect.String {
		newValue.SetString("李四")
	}
	return newValue
}

func main() {
	var modifyVal1 = 1
	var modifyVal2 = "你好"
	fmt.Println("【修改前】", modifyVal1, modifyVal2)
	res1 := reflectionModifiedVariableFunc(&modifyVal1)
	res2 := reflectionModifiedVariableFunc(&modifyVal2)
	fmt.Println("【修改后】", res1, res2)

}

通过反射修改结构体

package main

import (
	"fmt"
	"reflect"
)

type Student struct {
	Name string
	age  int
	Age  int
}

func main() {
	/* 通过反射修改结构体变量数据 */
	var stu = Student{"张三", 19, 20}
	fmt.Println("stu:", stu)

	stuStructValue := reflect.ValueOf(&stu)
	if stuStructValue.Kind() == reflect.Ptr {
		// 获取指针对象
		newValue := stuStructValue.Elem()
		if newValue.CanSet() {
			// 找到要修改结构体的字段
			// 反射：字段必须大写开头 , 小写触发恐慌 panic
			newValue.FieldByName("Name").SetString("lisi")
			newValue.FieldByName("Age").SetInt(333)
		}
	}
	fmt.Println("反射修改后的stu:", stu)

}

反射调用结构体方法

• MethodByName 找到函数名。必须大写
• Call 执行 函数。
  • 无参数 传入 nil
  • 有参数，传入Value类型

package main

import (
	"fmt"
	"reflect"
)

type StudentA struct {
	Name string
	Age  int
}

func (s StudentA) Say(content string) {
	/* 传入结构体方法 有参数*/
	fmt.Println(s.Name, "Say:【", content, "】")
}
func (s StudentA) GetInfo() {
	/* 传入结构体方法  无参数*/
	fmt.Printf("name: %s, age: %d\n", s.Name, s.Age)
}

func main() {
	/*
		通过 反射修 调用方法
		 - 1. MethodByName 找到函数名。必须大写
		 - 2. Call 执行 函数。
			- 2.1 无参数 传入 nil
			- 2.2 有参数，传入Value类型
	*/
	var stu = StudentA{"张三", 20}
	fmt.Println("stu:", stu)

	stuStructValue := reflect.ValueOf(&stu)
	fmt.Printf("stuStructValue Kind:%s, Type:%s\n", stuStructValue.Kind(), stuStructValue.Type())
	if stuStructValue.Kind() == reflect.Ptr {
		// 获取指针对象
		newValue := stuStructValue.Elem()
		fmt.Printf("newValue Kind:%s, Type:%s\n", newValue.Kind(), newValue.Type())

		// 无参函数，通过反射调用 . 传入 nil
		newValue.MethodByName("GetInfo").Call(nil)

		// 有参函数，通过反射调用。 传入 []Value
		args := make([]reflect.Value, 1)          // make 定义参数类型
		args[0] = reflect.ValueOf("这是反射调用") // 必须传入 Value类型的参数 。张三 Say:【 这是反射调用 】
		newValue.MethodByName("Say").Call(args)
	}

}

反射调用普通函数

package main

import (
	"fmt"
	"reflect"
)

func f1() {
	fmt.Println("无参函数")
}
func f2(i string) {
	fmt.Println("有参函数:", i)

}
func f3(i, s string) string {
	fmt.Println("有参函数，有返回值:", i, s)
	return s
}
func main() {
	/*
		反射调用函数
	*/
	// 无参
	v1 := reflect.ValueOf(f1)
	fmt.Println(v1.Kind(), v1.Type())
	v1.Call(nil)

	// 有参
	v2 := reflect.ValueOf(f2)
	fmt.Println(v2.Kind(), v2.Type())
	v2Args := make([]reflect.Value, 1)
	v2Args[0] = reflect.ValueOf("你好")
	v2.Call(v2Args)

	// 有参有返回值
	v3 := reflect.ValueOf(f3)
	fmt.Println(v3.Kind(), v3.Type())
	v3Args := make([]reflect.Value, 2)
	v3Args[0] = reflect.ValueOf("不好")
	v3Args[1] = reflect.ValueOf("aaa")
	v3.Call(v3Args)
}