reflect — 反射机制实战

var x int = 42
t := reflect.TypeOf(x)   // reflect.Type：类型元信息（int）
v := reflect.ValueOf(x)  // reflect.Value：具体值（42）

t := reflect.TypeFor[Config]()          // 等价于旧写法
old := reflect.TypeOf((*Config)(nil)).Elem()
fmt.Println(t == old)                   // true

ti := reflect.TypeFor[fmt.Stringer]()   // 接口类型也能直接取，Kind() == reflect.Interface

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

t := reflect.TypeFor[User]()

t.Name()        // "User"
t.String()      // "main.User"（带包路径）
t.Kind()        // reflect.Struct
t.NumField()    // 2
t.Field(0)      // reflect.StructField：Name/Type/Tag/Index/Anonymous
t.Tag.Get("json")            // 注意：要先拿 StructField 再 .Tag.Get
t.FieldByName("Name")        // (StructField, bool)，找不到 ok=false
t.NumMethod()   // 方法数（仅导出方法）
t.Elem()        // 指针/接口/切片的元素类型；非 Ptr 等会 panic

writerType := reflect.TypeFor[io.Writer]()           // Go 1.22 前只能写 (*io.Writer)(nil)).Elem()
fileType := reflect.TypeFor[os.File]().Elem()        // *os.File
fmt.Println(fileType.Implements(writerType))         // true（Write 定义在指针接收者上）

fmt.Println(reflect.Ptr == reflect.Pointer)                 // true（Ptr 是别名，src 注释："Ptr is the old name for the Pointer kind"）
fmt.Println(reflect.TypeFor[*int]().Kind())                 // ptr
fmt.Println(reflect.TypeFor[unsafe.Pointer]().Kind())       // unsafe.Pointer

v := reflect.ValueOf(42)
v.Kind()         // reflect.Int
v.Int()          // 42
v.Interface()    // any(42)，恢复为接口值

// 不可寻址：ValueOf 拿到的是拷贝
reflect.ValueOf(42).SetInt(100)
// panic: reflect: reflect.Value.SetInt using unaddressable value

// 可寻址：先取指针再 Elem()
x := 42
pv := reflect.ValueOf(&x).Elem()
pv.SetInt(100)                       // OK，x == 100；CanAddr/CanSet 均为 true

cfgv := reflect.ValueOf(&cfg).Elem()   // cfg 含非导出字段 name
_ = cfgv.Field(0).CanInterface()       // false
cfgv.Field(0).Interface()
// panic: reflect.Value.Interface: cannot return value obtained from unexported field or method
cfgv.Field(0).SetString("x")
// panic: reflect: reflect.Value.SetString using value obtained using unexported field

s := []int{1, 2, 3}
reflect.ValueOf(s).Index(1).SetInt(100)   // s == [1 100 3]，CanSet 为 true
m := map[string]int{"a": 1}
mv := reflect.ValueOf(m)
mv.SetMapIndex(reflect.ValueOf("a"), reflect.ValueOf(10))  // m == map[a:10]
// SetMapIndex(key, reflect.Value{}) —— 第二个参数传零值 Value 表示删除该键

ne := reflect.ValueOf((*int)(nil)).Elem()
ne.IsValid()      // false
ne.Kind()         // invalid
ne.Interface()    // panic: reflect: call of reflect.Value.Interface on zero Value

// Value.UnsafePointer（Go 1.18，api 核实）：返回 v 的 unsafe.Pointer，
// 取代已废弃的 Value.Pointer/Value.UnsafeAddr，Kind 限 Chan/Func/Map/Pointer/Slice/String/UnsafePointer
p := reflect.ValueOf(&x).UnsafePointer()

// Value.Comparable / Equal / SetZero（Go 1.20，api 核实）
reflect.ValueOf(map[string]int{}).Comparable()   // false（map/slice/func 均 false；接口值按动态类型判断）
reflect.Value{}.Equal(reflect.Value{})           // true（两个 invalid 值相等）
reflect.ValueOf(1).Equal(reflect.ValueOf("1"))   // false（类型不同直接 false，不 panic）
// 同类型但不可比较才 panic：
reflect.ValueOf([]int{1}).Equal(reflect.ValueOf([]int{1}))
// panic: reflect.Value.Equal: values of type []int are not comparable

sv := reflect.ValueOf(&x).Elem()
sv.SetZero()                                     // 置零，比 Set(零值Value) 省事；CanSet 为 false 时 panic

// Convert：按 Go 转换规则，转换本身会 panic 的 Convert 也 panic
reflect.ValueOf(42).Convert(reflect.TypeFor[int64]())   // OK
reflect.ValueOf(42).Convert(reflect.TypeFor[error]())
// panic: reflect.Value.Convert: value of type int cannot be converted to type error

func add(a, b int) int { return a + b }

fn := reflect.ValueOf(add)
args := []reflect.Value{reflect.ValueOf(2), reflect.ValueOf(3)}
results := fn.Call(args)
result := results[0].Int()  // 5

package main

import (
	"fmt"
	"reflect"
	"strings"
	"time"
)

type Config struct {
	Name    string        `json:"name" validate:"required"`
	Port    int           `json:"port" validate:"required"`
	Tags    []string      `json:"tags,omitempty"`
	Timeout time.Duration `json:"timeout"`
	secret  string
}

func parseStruct(v any) {
	val := reflect.ValueOf(v)
	typ := val.Type()
	fmt.Printf("type: %s (kind=%s, fields=%d)\n", typ.Name(), typ.Kind(), typ.NumField())
	for i := 0; i < typ.NumField(); i++ {
		sf := typ.Field(i)
		tag := sf.Tag.Get("json")
		name, opts, _ := strings.Cut(tag, ",")
		if name == "" {
			name = sf.Name
		}
		fv := val.Field(i)
		fmt.Printf("  %-8s %-13s json=%-9q opts=%-9v required=%-5v canSet=%v\n",
			sf.Name, sf.Type, name, opts != "",
			sf.Tag.Get("validate") == "required", fv.CanSet())
	}
}

func main() {
	cfg := Config{Name: "svc", Tags: []string{"a", "b"}, Timeout: time.Second}
	parseStruct(cfg)
	// FieldByName vs Field(i)
	t := reflect.TypeFor[Config]()
	f, ok := t.FieldByName("Port")
	fmt.Println("FieldByName(Port):", f.Index, ok)
	_, ok2 := t.FieldByName("Missing")
	fmt.Println("FieldByName(Missing):", ok2)
	// unexported field: Interface panic
	pv := reflect.ValueOf(&cfg).Elem()
	func() {
		defer func() { fmt.Println("recover:", recover()) }()
		_ = pv.Field(4).Interface()
	}()
	// addressability: pass by value vs pass by pointer
	func() {
		defer func() { fmt.Println("recover:", recover()) }()
		reflect.ValueOf(cfg).FieldByName("Port").SetInt(1)
	}()
	fmt.Println("via pointer, before:", pv.FieldByName("Port").Int())
	pv.FieldByName("Port").SetInt(8080)
	fmt.Println("via pointer, after :", cfg.Port)
}