Go語言的反射機制提供了在運行時檢查類型信息和操作變量的能力，使得程序能夠動態地處理未知類型的值。下面我將詳細介紹Go反射的核心概念、常用方法，並提供實用示例。

反射的基本概念

核心類型：reflect.Type 和 reflect.Value

package main

import (
    "fmt"
    "reflect"
)

type User struct {
    Name  string
    Age   int
    Email string
}

func main() {
    user := User{"Alice", 30, "alice@example.com"}
  
    // 獲取類型信息
    t := reflect.TypeOf(user)
    fmt.Printf("類型名稱: %v, 類型種類: %v\n", t.Name(), t.Kind())
  
    // 獲取值信息
    v := reflect.ValueOf(user)
    fmt.Printf("值: %v\n", v)
}

反射的常用操作

1. 檢查類型和種類

func inspectType(value interface{}) {
    t := reflect.TypeOf(value)
    v := reflect.ValueOf(value)
  
    fmt.Printf("類型: %v, 種類: %v\n", t, t.Kind())
  
    switch t.Kind() {
    case reflect.Struct:
        fmt.Println("這是一個結構體")
        // 遍歷結構體字段
        for i := 0; i < t.NumField(); i++ {
            field := t.Field(i)
            fieldValue := v.Field(i)
            fmt.Printf("字段 %d: %s (%s) = %v\n", 
                i, field.Name, field.Type, fieldValue.Interface())
        }
    case reflect.Slice:
        fmt.Printf("切片長度: %d\n", v.Len())
    case reflect.Map:
        fmt.Printf("映射鍵數量: %d\n", v.Len())
    }
}

// 使用示例
inspectType(User{"Bob", 25, "bob@example.com"})
inspectType([]int{1, 2, 3})
inspectType(map[string]int{"a": 1, "b": 2})

2. 動態修改值

func modifyValue() {
    // 修改普通變量
    x := 10
    v := reflect.ValueOf(&x).Elem() // 必須獲取可尋址的值
    v.SetInt(20)
    fmt.Println("修改後的x:", x)
  
    // 修改結構體字段
    user := User{"Charlie", 35, "charlie@example.com"}
    vUser := reflect.ValueOf(&user).Elem()
  
    nameField := vUser.FieldByName("Name")
    if nameField.IsValid() && nameField.CanSet() {
        nameField.SetString("David")
    }
  
    fmt.Println("修改後的user:", user)
}

3. 動態調用方法

type Calculator struct{}

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

func (c Calculator) Multiply(a, b int) int {
    return a * b
}

func callMethodDynamically() {
    calc := Calculator{}
    v := reflect.ValueOf(calc)
  
    // 調用Add方法
    method := v.MethodByName("Add")
    if method.IsValid() {
        args := []reflect.Value{
            reflect.ValueOf(10),
            reflect.ValueOf(5),
        }
        result := method.Call(args)
        fmt.Printf("10 + 5 = %d\n", result[0].Int())
    }
}

實用案例：通用配置解析器

package main

import (
    "fmt"
    "reflect"
    "strconv"
)

// Config 配置結構體
type Config struct {
    Host     string `default:"localhost"`
    Port     int    `default:"8080"`
    Debug    bool   `default:"true"`
    MaxConns int    `default:"100"`
}

// SetDefaults 使用反射設置默認值
func SetDefaults(config interface{}) {
    v := reflect.ValueOf(config).Elem()
    t := v.Type()
  
    for i := 0; i < t.NumField(); i++ {
        field := t.Field(i)
        fieldValue := v.Field(i)
      
        // 如果字段是零值且有默認標籤，則設置默認值
        if fieldValue.IsZero() {
            defaultValue := field.Tag.Get("default")
            if defaultValue != "" {
                setValue(fieldValue, defaultValue)
            }
        }
    }
}

func setValue(field reflect.Value, value string) {
    switch field.Kind() {
    case reflect.String:
        field.SetString(value)
    case reflect.Int:
        if intValue, err := strconv.Atoi(value); err == nil {
            field.SetInt(int64(intValue))
        }
    case reflect.Bool:
        if boolValue, err := strconv.ParseBool(value); err == nil {
            field.SetBool(boolValue)
        }
    }
}

func main() {
    config := &Config{Host: "myserver.com"} // 只設置Host，其他使用默認值
    SetDefaults(config)
  
    fmt.Printf("配置: %+v\n", config)
}

注意事項和最佳實踐

1. 性能考慮：反射操作比直接代碼調用慢，應在必要時使用
2. 類型安全：反射繞過了編譯時類型檢查，需要額外驗證
3. 可讀性：過度使用反射會降低代碼可讀性

// 安全的類型斷言輔助函數
func safeSetString(field reflect.Value, value string) error {
    if field.Kind() != reflect.String {
        return fmt.Errorf("字段不是字符串類型")
    }
    if !field.CanSet() {
        return fmt.Errorf("字段不可設置")
    }
    field.SetString(value)
    return nil
}

總結

Go的反射機制是一把雙刃劍，它提供了強大的動態編程能力，但也帶來了性能開銷和複雜性。合理使用反射可以實現：

• 通用庫和框架開發
• 數據序列化/反序列化
• 配置處理
• 插件系統等高級功能

掌握反射的關鍵是理解reflect.Type和reflect.Value的使用，以及何時使用反射才是恰當的解決方案。