第13章 反射

反射的引入

【1】反射可以做什麼？

1) 反射可以在運作時動态擷取變量的各種資訊，比如變量的類型，類别等資訊

2) 如果是結構體變量，還可以擷取到結構體本身的資訊(包括結構體的字段、方法)

3) 通過反射，可以修改變量的值，可以調用關聯的方法。

4) 使用反射，需要import ("reflect")

【2】反射相關的函數

1) reflect.TypeOf(變量名)，擷取變量的類型，.Type類型

2) reflect.ValueOf(變量名)，擷取變量的值，傳回reflect.Value類型(reflect.Value是一個結構體類型),通過reflect.Value，可以擷取到關于該變量的很多資訊。

對基本資料類型反射

【1】反射相關的函數

1) reflect.TypeOf(變量名)，擷取變量的類型，傳回reflect.Type類型

2) reflect.ValueOf(變量名)，擷取變量的值，傳回reflect.Value類型(reflect.Value是一個結構體類型),通過reflect.Value，可以擷取到關于該變量的很多資訊。

【2】代碼：

package main

import (
	"fmt"
	"reflect"
)

//利用一個函數，函數的參數定義為空接口：
//空接口沒有任何方法,是以可以了解為所有類型都實作了空接口，也可以了解為我們可以把任何一個變量賦給空接口。
func testReflect(i interface{})  {

	//1.調用TypeOf函數，傳回reflect.Type類型資料：
	reType := reflect.TypeOf(i)
	fmt.Println("reType:",reType)
	fmt.Printf("reType的具體類型是：%T \n",reType)
	//2.調用ValueOf函數，傳回reflect.Value類型資料：
	reValue := reflect.ValueOf(i)
	fmt.Println("reValue",reValue)
	fmt.Printf("reValue的具體類型是：%T \n",reValue)

	// num1 := 100
	//如果真想擷取reValue的數值，要調用Int()方法：傳回v持有的有符号整數
	num2 := 80 + reValue.Int()
	fmt.Println(num2)

	//reValue轉成空接口：
	i2 := reValue.Interface()
	n := i2.(int)
	n2 := n + 30
	fmt.Println(n2)
}

func main()  {
	var num int = 100;
	testReflect(num)
}           

對結構體類型反射

【1】反射相關的函數

1) reflect.TypeOf(變量名)，擷取變量的類型，傳回reflect.Type類型

2) reflect.ValueOf(變量名)，擷取變量的值，傳回reflect.Value類型(reflect.Value是一個結構體類型),通過reflect.Value，可以擷取到關于該變量的很多資訊。

【2】代碼：

package main

import (
	"fmt"
	"reflect"
)

//利用一個函數，函數的參數定義為空接口：
//空接口沒有任何方法,是以可以了解為所有類型都實作了空接口，也可以了解為我們可以把任何一個變量賦給空接口。
func testReflect(i interface{})  {

	//1.調用TypeOf函數，傳回reflect.Type類型資料：
	reType := reflect.TypeOf(i)
	fmt.Println("reType:",reType)
	fmt.Printf("reType的具體類型是：%T \n",reType)
	//2.調用ValueOf函數，傳回reflect.Value類型資料：
	reValue := reflect.ValueOf(i)
	fmt.Println("reValue",reValue)
	fmt.Printf("reValue的具體類型是：%T \n",reValue)
	// num1 := 100
	//如果真想擷取reValue的數值，要調用Int()方法：傳回v持有的有符号整數
	num2 := 80 + reValue.Int()
	fmt.Println(num2)

	//reValue轉成空接口：
	i2 := reValue.Interface()
	n := i2.(int)
	n2 := n + 30
	fmt.Println(n2)
}

func main()  {
	var num int = 100;
	testReflect(num)
}           

擷取變量的類别

【1】擷取變量的類别：兩種方式：

（1）reflect.Type.Kind()

（2）reflect.Value.Kind()

【2】Kind的值是常量值：

【3】代碼：

package main

import (
	"fmt"
	"reflect"
)

type Student struct {
	Name string
	Age int
}

func testReflect(i interface{})  {
	reType := reflect.TypeOf(i)
	reValue := reflect.ValueOf(i)

	//擷取變量的類别：
	//（1）reType.Kind()
	k1 := reType.Kind()
	fmt.Println(k1)

	//（2）reValue.Kind()
	k2 := reValue.Kind()
	fmt.Println(k2)

	//擷取變量的類型：
	i2 := reValue.Interface()
	n,flag := i2.(Student)
	if flag == true {
		fmt.Printf("結構體的類型是：%T",n)
	}
}

func main()  {
	stu := Student{
		Name: "菜園子",
		Age: 18,
	}
	testReflect(stu)
}           

【4】Type和 Kind 的差別

Type是類型, Kind是類别,Type和Kind 可能是相同的，也可能是不同的.

比如:var num int = 10 num的Type是int , Kind也是int

比如:var stu Studentstu的 Type是 pkg1.Student , Kind是struct

通過反射修改變量

修改基本資料類型的值：

package main

import (
	"fmt"
	"reflect"
)

func testReflect(i interface{})  {
	reValue := reflect.ValueOf(i)
	//通過SetInt()來改變值：
	reValue.Elem().SetInt(50)
}

func main()  {
	var num int = 100
	//傳入指針位址
	testReflect(&num)
	fmt.Println(num)
}           

通過反射操作結構體的屬性和方法

【1】代碼：（熟知API）

package main

import (
	"fmt"
	"reflect"
)

type Student struct {
	Name string
	Age int
}

//給結構體綁定方法：
func (s Student) Print()  {
	fmt.Println("調用了Print()方法")
	fmt.Println("學生的名字是：",s.Name)
}

func (s Student) GetSum(n1,n2 int) int{
	fmt.Println("調用了GetSum()方法")
	return n1 + n2
}

func (s Student) Set(name string,age int)  {
	s.Name = name
	s.Age = age
}

//定義函數操作結構體進行反射操作：
func TestStudentStruct(a interface{})  {
	//a轉成reflect.Value類型：
	val := reflect.ValueOf(a)
	fmt.Println(val)

	//通過reflect.Value類型操作結構體内部的字段：
	n1 := val.NumField()
	fmt.Println(n1)
	//周遊-擷取具體的字段：
	for i := 0; i < n1; i++ {
		fmt.Printf("第%d個字段的值是：%v \n",i+1,val.Field(i))
	}

	//通過reflect.Value類型操作結構體内部的方法：
	n2 := val.NumMethod()
	fmt.Println(n2)

	//調用Print()方法：
	//調用方法，方法的首字母必須大寫才能有對應的反射的通路權限
    //方法的順序按照ASCII的順序排列的，a,b,c,,,,,,索引：0,1,2，，，
	val.Method(1).Call(nil)

	//調用GetSum方法：
	//定義Value的切片：
	var params []reflect.Value
	params = append(params,reflect.ValueOf(10))
	params = append(params,reflect.ValueOf(20))
	result := val.Method(0).Call(params)
	fmt.Println("GetSum方法的傳回值是：",result[0].Int())
}

func main()  {
	stu := Student{
		Name: "菜園子",
		Age: 19,
	}
	TestStudentStruct(stu)
}           

通過反射修改變量

【1】代碼：

package main

import (
	"fmt"
	"reflect"
)

type Student struct{
	Name string
	Age int
}

func (s Student) Print() {
	fmt.Println("調用了Print()方法")
	fmt.Println("學生的姓名是：",s.Name)
}

func (s Student) GetSum(n1,n2 int) int {
	fmt.Println("調用了GetSum()方法")
	return n1 + n2
}

func (s Student) Set(name string,age int)  {
	s.Name = name
	s.Age = age
}

func TestReflectStuct(a interface{})  {
	//a轉成reflect.Value類型：
	val := reflect.ValueOf(a)
	fmt.Println(val)

	n := val.Elem().NumField()
	fmt.Println(n)

	//修改字段的值：
	val.Elem().Field(0).SetString("Idea")
}

func main()  {
	stu := Student {
		Name: "菜園子",
		Age: 19,
	}

	TestReflectStuct(&stu)

	fmt.Println(stu)
}           

參考源碼:golang-demo: golang學習

參考部落格：cyz