變數機制
在Go語言中，變數分為兩部分。
型別資訊：預先定義好的變數型別，屬於元資訊
值資訊：程式執行過程中可變化的一部分資訊
反射介紹
反射是指在程式執行期對程式本身進行訪問和修改的能力。程式在編譯時，變數被轉換為記憶體地址，變數名不會被編譯器寫入到可執行部分。在執行程式時，程式無法獲取自身的資訊。
支援反射的語言可以在程式編譯期將變數的反射資訊，如欄位名稱、型別資訊、結構體資訊等整合到可執行檔案中，並給程式提供介面訪問反射資訊，這樣就可以在程式執行期獲取型別的反射資訊，並且有能力修改它們。
Go程式在執行期使用reflect包訪問程式的反射資訊。
空介面可以儲存任意型別的變數，那我們如何知道這個空介面儲存的資料是什麼呢？ 反射就是在執行時動態的獲取一個變數的型別資訊和值資訊。
反射就是對空介面擁有更靈活的處理
reflect包
在Go語言的反射機制中，任何介面值都由是一個具體型別和具體型別的值兩部分組成的。
在Go語言中反射的相關功能由內建的reflect包提供，任意介面值在反射中都可以理解為由reflect.Type和reflect.Value兩部分組成，並且reflect包提供了reflect.TypeOf和reflect.ValueOf兩個函式來獲取任意物件的Value和Type。
TypeOf()
在Go語言中，使用reflect.TypeOf()函式可以獲得任意值的型別物件（reflect.Type），程式通過型別物件可以訪問任意值的型別資訊。
該方法獲取的型別物件是淺層的，意思在於如果是自定義物件不能獲取到其根本的物件。
package main
import (
"fmt"
"reflect"
)
func getType(v1 interface{}){
t := reflect.TypeOf(v1)
fmt.Println(t) // float64
}
func main(){
var num float64
num = 3.14
getType(num)
}
深層型別與種類
Go中由於支援自定義型別，所以還存在深層型別的說法，除此之外還有種類的說法。
如何理解種類呢？比如一個map[string]int64與map[string]interface{}它們的型別並不一樣，但是都是屬於map這個種類的。
注意：Go語言的反射中像陣列、切片、Map、指標等型別的變數，它們的.Name()都是返回空。
package main
import (
"fmt"
"reflect"
)
func getType(v1 interface{}) string {
t := reflect.TypeOf(v1)
return fmt.Sprintf("淺層型別Type：%s,深層型別Name:%s,種類Kind:%s", t, t.Name(), t.Kind())
}
func main() {
var n1 float64
n1 = 3.14
result := getType(n1)
fmt.Println(result) // 淺層型別Type：float64,深層型別Name:float64,種類Kind:float64
type iInt int // 自定義型別
var n2 iInt
n2 = 1000
result = getType(n2)
fmt.Println(result) // 淺層型別Type：main.iInt,深層型別Name:iInt,種類Kind:int
type iFloat = float64 // 型別別名
var n3 iFloat
n3 = 3.15
result = getType(n3)
fmt.Println(result) // 淺層型別Type：float64,深層型別Name:float64,種類Kind:float64
}
在reflect包中，定義的種類Kind如下：
type Kind uint
const (
Invalid Kind = iota // 非法型別
Bool // 布林型
Int // 有符號整型
Int8 // 有符號8位整型
Int16 // 有符號16位整型
Int32 // 有符號32位整型
Int64 // 有符號64位整型
Uint // 無符號整型
Uint8 // 無符號8位整型
Uint16 // 無符號16位整型
Uint32 // 無符號32位整型
Uint64 // 無符號64位整型
Uintptr // 指標
Float32 // 單精度浮點數
Float64 // 雙精度浮點數
Complex64 // 64位複數型別
Complex128 // 128位複數型別
Array // 陣列
Chan // 通道
Func // 函式
Interface // 介面
Map // 對映
Ptr // 指標
Slice // 切片
String // 字串
Struct // 結構體
UnsafePointer // 底層指標
)
ValueOf()
reflect.ValueOf()用於返回原始值，下面是支援獲取值的型別。
| 方法 | 說明 |
|---|---|
| Interface() interface {} | 將值以 interface{} 型別返回，可以通過型別斷言轉換為指定型別 |
| Int() int64 | 將值以 int 型別返回，所有有符號整型均可以此方式返回 |
| Uint() uint64 | 將值以 uint 型別返回，所有無符號整型均可以此方式返回 |
| Float() float64 | 將值以雙精度（float64）型別返回，所有浮點數（float32、float64）均可以此方式返回 |
| Bool() bool | 將值以 bool 型別返回 |
| Bytes() []bytes | 將值以位元組陣列 []bytes 型別返回 |
| String() string | 將值以字串型別返回 |
反射獲取值
如下示例：
package main
import (
"reflect"
"fmt"
)
func getValue(v1 interface{}) interface{} {
value := reflect.ValueOf(v1) // 獲取原始值
kind := value.Kind() // 獲取種類
switch kind {
case reflect.Int64:
return int64(value.Int()) // 返回
case reflect.Float32, reflect.Float64:
return float32(value.Float())
default:
return "不支援獲取該型別"
}
}
func main() {
var n1 float32
n1 = 3.14
result := getValue(n1)
fmt.Printf("%T\n",result) // float32
}
反射設定值
由於在函式中傳遞的都是值拷貝，以前我們想設定原本的值必須傳入指標變數。
通過反射的Elem()方法可以進行值設定，這常用在傳入值是空介面時。
package main
import (
"fmt"
"reflect"
)
func setValue(v1 interface{}) { // 傳入空介面
value := reflect.ValueOf(v1) // 獲取原始值
kind := value.Elem().Kind()
switch kind { // 進行種類捕獲
case reflect.Int64:
value.Elem().SetInt(1000) // 若不使用Elem則會丟擲異常
case reflect.Float32, reflect.Float64:
value.Elem().SetFloat(1.11)
default:
fmt.Println("你傳入的型別讓我無法設定")
}
}
func main() {
var n1 float32
n1 = 3.14
setValue(&n1) // 傳入地址
fmt.Println(n1) // 1.11
}
IsNil()
使用格式：
func (v Value) IsNil() bool
IsNil()報告v持有的值是否為nil。v持有的值的分類必須是通道、函式、介面、對映、指標、切片之一；否則IsNil()函式會導致panic。
IsNil()常被用於判斷指標是否為空
package main
import (
"fmt"
"reflect"
)
func main() {
var a *int // int型別空指標
fmt.Println(reflect.ValueOf(a).IsNil()) // true
}
IsVaild()
使用格式：
func (v Value) IsValid() bool
IsValid()返回v是否持有一個值。如果v是Value零值會返回假，此時v除了IsValid()、String()、Kind()之外的方法都會導致panic()。
IsValid()常被用於判定返回值是否有效。
package main
import (
"fmt"
"reflect"
)
func main() {
b := struct{}{}
// 嘗試從結構體中查詢"abc"欄位
fmt.Println("不存在的結構體成員:", reflect.ValueOf(b).FieldByName("abc").IsValid())
// 嘗試從結構體中查詢"abc"方法
fmt.Println("不存在的結構體方法:", reflect.ValueOf(b).MethodByName("abc").IsValid())
// map
c := map[string]int{}
// 嘗試從map中查詢一個不存在的鍵
fmt.Println("map中不存在的鍵：", reflect.ValueOf(c).MapIndex(reflect.ValueOf("和尚")).IsValid())
}
結構體反射
JSON是如何反序列化為結構體的？這就蘊含結構體反射的內容了。
任意值通過reflect.TypeOf()獲得反射物件資訊後，如果它的型別是結構體，可以通過反射值物件（reflect.Type）的NumField()和Field()方法獲得結構體成員的詳細資訊。
reflect.Type中與獲取結構體成員相關的的方法如下表所示。
| 方法 | 說明 |
|---|---|
| Field(i int) StructField | 根據索引，返回索引對應的結構體欄位的資訊。 |
| NumField() int | 返回結構體成員欄位數量。 |
| FieldByName(name string) (StructField, bool) | 根據給定字串返回字串對應的結構體欄位的資訊。 |
| FieldByIndex(index []int) StructField | 多層成員訪問時，根據 []int 提供的每個結構體的欄位索引，返回欄位的資訊。 |
| FieldByNameFunc(match func(string) bool) (StructField,bool) | 根據傳入的匹配函式匹配需要的欄位。 |
| NumMethod() int | 返回該型別的方法集中方法的數目 |
| Method(int) Method | 返回該型別方法集中的第i個方法 |
| MethodByName(string)(Method, bool) | 根據方法名返回該型別方法集中的方法 |
StructField型別
StructField型別用來描述結構體中的一個欄位的資訊。
StructField的定義如下：
type StructField struct {
// Name是欄位的名字。PkgPath是非匯出欄位的包路徑，對匯出欄位該欄位為""。
// 參見http://golang.org/ref/spec#Uniqueness_of_identifiers
Name string
PkgPath string
Type Type // 欄位的型別
Tag StructTag // 欄位的標籤
Offset uintptr // 欄位在結構體中的位元組偏移量
Index []int // 用於Type.FieldByIndex時的索引切片
Anonymous bool // 是否匿名欄位
}
結構體反射示例
當我們使用反射得到一個結構體資料之後可以通過索引依次獲取其欄位資訊，也可以通過欄位名去獲取指定的欄位資訊。
type student struct {
Name string `json:"name"`
Score int `json:"score"`
}
func main() {
stu1 := student{
Name: "小王子",
Score: 90,
}
t := reflect.TypeOf(stu1)
fmt.Println(t.Name(), t.Kind()) // student struct
// 通過for迴圈遍歷結構體的所有欄位資訊
for i := 0; i < t.NumField(); i++ {
field := t.Field(i)
fmt.Printf("name:%s index:%d type:%v json tag:%v\n", field.Name, field.Index, field.Type, field.Tag.Get("json"))
}
// 通過欄位名獲取指定結構體欄位資訊
if scoreField, ok := t.FieldByName("Score"); ok {
fmt.Printf("name:%s index:%d type:%v json tag:%v\n", scoreField.Name, scoreField.Index, scoreField.Type, scoreField.Tag.Get("json"))
}
}
接下來編寫一個函式printMethod(s interface{})來遍歷列印s包含的方法。
// 給student新增兩個方法 Study和Sleep(注意首字母大寫)
func (s student) Study() string {
msg := "好好學習，天天向上。"
fmt.Println(msg)
return msg
}
func (s student) Sleep() string {
msg := "好好睡覺，快快長大。"
fmt.Println(msg)
return msg
}
func printMethod(x interface{}) {
t := reflect.TypeOf(x)
v := reflect.ValueOf(x)
fmt.Println(t.NumMethod())
for i := 0; i < v.NumMethod(); i++ {
methodType := v.Method(i).Type()
fmt.Printf("method name:%s\n", t.Method(i).Name)
fmt.Printf("method:%s\n", methodType)
// 通過反射呼叫方法傳遞的引數必須是 []reflect.Value 型別
var args = []reflect.Value{}
v.Method(i).Call(args)
}
}
反射是把雙刃劍
反射是一個強大並富有表現力的工具，能讓我們寫出更靈活的程式碼。但是反射不應該被濫用，原因有以下三個。
- 基於反射的程式碼是極其脆弱的，反射中的型別錯誤會在真正執行的時候才會引發panic，那很可能是在程式碼寫完的很長時間之後。
- 大量使用反射的程式碼通常難以理解。
- 反射的效能低下，基於反射實現的程式碼通常比正常程式碼執行速度慢一到兩個數量級。
例項操作
需求分析
解析ini配置檔案，如下有一個ini配置檔案。
[mysql]
address = 10.20.30.40
port = 3306
username = root
password = rootroot
如何將內容解析到下面這個結構體中？
package main
import (
"errors"
"fmt"
"io/ioutil"
"reflect"
"strconv"
"strings"
)
// Config 配置檔案結構體
type Config struct {
MysqlConfig `ini:"mysql"`
}
// MysqlConfig MySQL配置結構體，結構體欄位需要與配置檔案中的對應。
type MysqlConfig struct {
Address string `ini:"address"`
Port int `ini:"port"`
Username string `ini:"username"`
Password string `ini:"password"`
}
func loadIni(fileName string, data interface{}) (err error) {
// 補全程式碼
}
func main() {
var cfg Config
err := loadIni("./conf.ini", &cfg)
if err != nil {
fmt.Printf("load ini failed err%v \n", err)
return
}
fmt.Println(cfg)
}
解決方案
其實只要開啟配置檔案每一行進行讀取，再拿到結構體欄位後對比tag。如果tag相同則將配置檔案中的資料寫入到結構體中即可。
package main
import (
"errors"
"fmt"
"io/ioutil"
"reflect"
"strconv"
"strings"
)
// Config 配置檔案結構體
type Config struct {
MysqlConfig `ini:"mysql"`
}
// MysqlConfig MySQL配置結構體
type MysqlConfig struct {
Address string `ini:"address"`
Port int `ini:"port"`
Username string `ini:"username"`
Password string `ini:"password"`
}
func loadIni(fileName string, data interface{}) (err error) {
var sectionName string // 節點名稱
var structName string // 結構體名字
// 引數校驗：
// 傳入的data引數是否是一個結構體指標型別（要對結構體進行欄位填充）
t := reflect.TypeOf(data)
// 判斷是否是指標
if t.Kind() != reflect.Ptr {
err = errors.New("data should be a pointer")
return err
}
// 判斷是否是結構體指標
if t.Elem().Kind() != reflect.Struct {
err = errors.New("data should be a Struct pointer")
return err
}
// 1.讀檔案，得到位元組型別的資料,轉換為字串
b, err := ioutil.ReadFile(fileName)
if err != nil {
return
}
lineSlice := strings.Split(string(b), "\n")
// 2 一行一行讀資料，如果是註釋就忽略
// 3 一行一行讀資料，如果是[開頭的則代表是一個節點
// 4 一行一行讀資料，如不不是[開頭的就是=號分割的鍵值對
for idex, line := range lineSlice {
// 去空格
line = strings.TrimSpace(line)
// 過濾空行
if len(line) == 0 {
continue
}
// 這是註釋
if strings.HasPrefix(line, ";") {
continue
}
// 這是[開頭的節點
if strings.HasPrefix(line, "[") {
// 不合格的節點
if line[0] != '[' || line[len(line)-1] != ']' {
err = fmt.Errorf("line:%d syntax error", idex+1)
return err
}
// []裡沒有內容
sectionName = strings.TrimSpace(line[1:(len(line) - 1)])
if len(sectionName) == 0 {
err = fmt.Errorf("line:%d syntax error", idex+1)
return err
}
// v := reflect.ValueOf(data)
// 根據sectionName找結構體
for i := 0; i < t.Elem().NumField(); i++ {
field := t.Elem().Field(i)
if sectionName == field.Tag.Get("ini") {
// 找到了巢狀結構體，記錄欄位名
structName = field.Name
fmt.Printf("找到%s對應的巢狀結構體%s\n", sectionName, structName)
}
}
} else {
// 等號進行分割，k = v
if strings.Index(line, "=") == -1 || strings.HasPrefix(line, "=") || strings.HasSuffix(line, "=") {
err = fmt.Errorf("line:%d syntax error", idex+1)
return err
}
index := strings.Index(line, "=")
key := strings.TrimSpace(line[:index])
value := strings.TrimSpace(line[index+1:])
// 根據strucrName在data中拿到對應的巢狀結構體
v := reflect.ValueOf(data)
sValue := v.Elem().FieldByName(structName) // 拿到巢狀結構體的值資訊
sType := sValue.Type() // 拿到巢狀結構體的型別資訊
if sType.Kind() != reflect.Struct {
err = fmt.Errorf("data中的%s欄位在結構體中不存在", structName)
return err
}
var filedName string
var fileType reflect.StructField
// 遍歷巢狀結構體的欄位，判斷tag是否等於key
for i := 0; i < sValue.NumField(); i++ {
filed := sType.Field(i) // tag資訊儲存在型別中
fileType = filed
if filed.Tag.Get("ini") == key {
// 找到欄位
filedName = filed.Name
break
}
}
if len(filedName) == 0 {
// 結構體中找不到對應的欄位
continue
}
// 如果key == tag 給欄位進行賦值
fileObj := sValue.FieldByName(filedName)
// 賦值
switch fileType.Type.Kind() {
case reflect.String:
fileObj.SetString(value)
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
var valueInt int64
valueInt, err = strconv.ParseInt(value, 10, 64)
if err != nil {
err = fmt.Errorf("line:%d value type error", idex+1)
return err
}
fileObj.SetInt(valueInt)
case reflect.Bool:
var valueBool bool
valueBool, err = strconv.ParseBool(value)
if err != nil {
err = fmt.Errorf("line:%d value type error", idex+1)
return err
}
fileObj.SetBool(valueBool)
case reflect.Float32, reflect.Float64:
var valueFloat float64
valueFloat, err = strconv.ParseFloat(value, 64)
if err != nil {
err = fmt.Errorf("line:%d value type error", idex+1)
return err
}
fileObj.SetFloat(valueFloat)
}
}
}
return
}
func main() {
var cfg Config
err := loadIni("./conf.ini", &cfg)
if err != nil {
fmt.Printf("load ini failed err%v \n", err)
return
}
fmt.Println(cfg)
}