Reflect：Go 語言的鏡子

👨‍💻簡介

在 Go 語言中，reflect package是用來檢查和操作變數的type、value和struct。常見用法有檢察 type、調用方法，以及修改變數的value。今天簡單介紹 reflect package的主要功能、使用方法和常見用法。

主要功能

reflect package 主要用來在運行時檢查和操作變數的type訊息。這對於需要在不確定type的情況下處理資料的情況非常有用。要使用reflect package，首先需要import它：

import "reflect"

reflect package的主要功能包括：

Type reflect

reflect 可以讓你取得變數的type訊息，方便我們在運行時進行type比較，檢查變數的type。下面是一些基本的type reflect操作：

reflect.TypeOf：取得變數的type。
reflect.ValueOf：取得變數的value。
reflect.Zero：建立一個zero value。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var num int
	typ := reflect.TypeOf(num)
	val := reflect.ValueOf(num)
	zeroVal := reflect.Zero(typ)

	fmt.Printf("Type: %v\n", typ)            // Type: int
	fmt.Printf("Value: %v\n", val)           // Value: 0
	fmt.Printf("Zero Value: %v\n", zeroVal)  // Zero Value: 0
}

Struct reflect

reflect 可以讓你取得struct欄位的訊息，訪問struct欄位的value，以及修改struct欄位的value。

reflect.Value.Field：取得struct欄位的value。
reflect.Value.FieldByName：根據欄位名稱取得struct欄位的value。
reflect.Value.FieldByIndex：根據欄位索引取得struct欄位的value。
reflect.Value.FieldByNameFunc：使用自定義函數查找欄位。
reflect.Value.Set：設定變數的value。

package main

import (
	"fmt"
	"reflect"
)

type Person struct {
	Name string
	Age  int
}

func main() {
	person := Person{Name: "Alan", Age: 30}
	val := reflect.ValueOf(person)

	nameField := val.FieldByName("Name")
	fmt.Printf("Name: %v\n", nameField) // Name: "Alan"

	ageField := val.FieldByName("Age")
	fmt.Printf("Age: %v\n", ageField)   // Age: 30

	val.FieldByName("Age").SetInt(31)
	fmt.Printf("Updated Age: %v\n", person.Age) // Updated Age: 31
}

方法 reflect

reflect 也可以調用struct的方法。

reflect.Value.Method：取得struct方法。
reflect.Value.MethodByName：根據方法名取得struct方法。
reflect.Value.Call：調用方法。

package main

import (
	"fmt"
	"reflect"
)

type Calculator struct{}

func (c Calculator) Add(a, b int) int {
	return a + b
}

func main() {

	calculator := Calculator{}

	// 使用 reflect.ValueOf 取得計算器物件的reflect value
	val := reflect.ValueOf(calculator)

	// 使用 MethodByName 方法取得名為 "Add" 的方法的reflect value
	method := val.MethodByName("Add")

	// 準備方法的參數
	args := []reflect.Value{reflect.ValueOf(5), reflect.ValueOf(3)}

	// 調用方法並取得結果，然後轉換為整數型別
	result := method.Call(args)[0].Interface().(int)

	fmt.Printf("Result: %d\n", result) // Result: 8
}

建立新的value

reflect 也可以用來建立一個新的變數，並設定它的value。先建立變數的類型，然後使用 reflect.New 方法來建立，最後使用 Elem 方法取得可設定value的對象：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	// 取得整數類型的 reflect.Type
	intType := reflect.TypeOf(0)

	// 建立一個新的整數變數
	newInt := reflect.New(intType).Elem()

	// 設定變數的value
	newInt.SetInt(42)

	// 取得變數的value
	fmt.Println("New Integer Value:", newInt.Int()) // 42
}

修改變數的value

要使用 reflect 修改變數的value，有以下步驟：

使用 reflect.ValueOf 函數取得變數的 reflect.Value。
使用 .Elem() 方法取得可寫的value（如果原始value是pointer或interface）。
使用 CanSet 方法確保value可寫。
使用 SetXXX 方法設定新的value，其中 XXX 是所需的資料type。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	// 創建一個整數變數
	var num int = 42

	// 使用 reflect.ValueOf 取得 reflect.Value
	valueOfNum := reflect.ValueOf(&num).Elem()

	// 使用 Elem() 取得可寫的value
	if valueOfNum.CanSet() {
		// 使用 SetInt 設定新的整數value
		valueOfNum.SetInt(99)
	}

	fmt.Println("Updated Value:", num) // 99
}

在上面的範例中，我們首先使用 reflect.ValueOf 取得整數變數 num 的 reflect.Value，然後使用 .Elem() 方法取得可寫的value。最後，我們使用 SetInt 方法設定新的整數value。請注意，只有在可寫的value上才能使用 SetXXX 方法，使用前記得使用 CanSet 方法來確保value是可寫的。

檢查是否有效和是否為空

reflect package 還提供了 IsValid 和 IsNil 方法，用來檢查 reflect value是否有效（不為zero value）和是否為nil pointer。這在處理 reflect value時非常有用，可以避免意外的錯誤。

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var num int = 42
	value := reflect.ValueOf(num)

	if value.IsValid() {
		fmt.Println("Value is valid")
	}

	var ptr *int
	ptrValue := reflect.ValueOf(ptr)

	if ptrValue.IsValid() {
		fmt.Println("Pointer Value is valid")
	} else if ptrValue.IsNil() {
		fmt.Println("Pointer Value is nil")
	}
}

常見用法

檢查Interface的動態type

package main

import (
	"fmt"
	"reflect"
)

func main() {
	var x interface{} = 42
	val := reflect.ValueOf(x)

	if val.Type() == reflect.TypeOf(0) {
		fmt.Printf("Value is an integer: %d\n", val.Int())
	} else {
		fmt.Printf("Value is not an integer\n")
	}
}

遍歷struct的欄位

reflect package 可以用來遍歷struct的欄位，這在某些情況下很有用，例如序列化或檢查struct的欄位屬性：

package main

import (
	"fmt"
	"reflect"
)

type Person struct {
	Name    string
	Age     int
	Address string
}

func main() {
	p := Person{"Alan", 30, "123 Main St"}
	valueOfP := reflect.ValueOf(p)

	for i := 0; i < valueOfP.NumField(); i++ {
		field := valueOfP.Field(i)
		fmt.Printf("Field Name: %s, Field Value: %v\n", valueOfP.Type().Field(i).Name, field.Interface())
	}
}

檢查方法是否存在

你可以使用reflect package 檢查struct是否實現了某個方法：

package main

import (
	"fmt"
	"reflect"
)

type Person struct {
	Name string
	Age  int
}

func (p Person) SayHello() {
	fmt.Println("Hello, my name is", p.Name)
}

func main() {
	p := Person{"Alan", 30}
	valueOfP := reflect.ValueOf(p)

	method := valueOfP.MethodByName("SayHello")
	if method.IsValid() {
		fmt.Println("SayHello method exists")
	} else {
		fmt.Println("SayHello method does not exist")
	}
}

操作切片和映射

reflect package 可以用來動態操作切片和映射的元素：

package main

import (
	"fmt"
	"reflect"
)

func main() {
	slice := []int{1, 2, 3}
	mapVal := map[string]int{"a": 1, "b": 2}

	sliceValue := reflect.ValueOf(slice)
	mapValue := reflect.ValueOf(mapVal)

	// 修改切片和映射的元素
	sliceValue.Index(0).SetInt(42)
	mapValue.SetMapIndex(reflect.ValueOf("b"), reflect.ValueOf(99))

	fmt.Println(slice) // [42 2 3]
	fmt.Println(mapVal) // map[a:1 b:99]
}

👨‍💻簡介#

主要功能#

Type reflect#

Struct reflect#

方法 reflect#

建立新的value#

修改變數的value#

檢查是否有效和是否為空#

常見用法#

檢查Interface的動態type#

遍歷struct的欄位#

檢查方法是否存在#

操作切片和映射#

📚參考資料#