Go reflect.TypeFor 在泛型代码中怎么获取类型信息：nil、指针与缓存边界

做一个泛型类型注册表时，最容易绕远路的地方是“我明明知道 T，为什么还要先造一个零值，再交给 reflect.TypeOf”。Go 1.22 加入的 reflect.TypeFor[T]() 直接返回类型参数的 reflect.Type，因此注册表可以把“静态已知类型”和“运行时拿到的值”分开处理。

如果类型来自泛型参数，优先用 reflect.TypeFor[T]()；如果类型来自一个运行时接口值，仍然用 reflect.TypeOf(value)，并单独处理 nil。

先把类型注册表的目标说清楚

假设一个小型消息总线按 Go 类型分派处理器：UserCreated 交给用户处理器，OrderPaid 交给订单处理器。注册动作发生在编译期已经写死的泛型函数里，运行时真正到达的是一个 reflect.Type 键。

package main

import (
    "fmt"
    "reflect"
)

type UserCreated struct{ ID int }
type OrderPaid struct{ ID int }

type Registry struct {
    handlers map[reflect.Type]string
}

func NewRegistry() *Registry {
    return &Registry{handlers: make(map[reflect.Type]string)}
}

func (r *Registry) Register[T any](name string) {
    r.handlers[reflect.TypeFor[T]()] = name
}

func (r *Registry) Find(value any) (string, bool) {
    if value == nil {
        return "", false
    }
    name, ok := r.handlers[reflect.TypeOf(value)]
    return name, ok
}

func main() {
    r := NewRegistry()
    r.Register[UserCreated]("user-created")
    r.Register[OrderPaid]("order-paid")
    fmt.Println(r.Find(UserCreated{ID: 7}))
}

这里的调用链很短：Register[T] 用 TypeFor[T]() 写入 map，Find(value) 用 TypeOf(value) 查找。两边只有在类型完全一致时才能命中，值类型和指针类型不会自动合并。

TypeFor 与 TypeOf：一个看 T，一个看值

reflect.TypeFor[T]() 的 T 是编译器已经知道的类型参数；它不读取某个实例的动态类型。相反，reflect.TypeOf(value) 接受接口值，返回接口里实际装着的动态类型。

因此不要把 TypeFor[T]() 写成“更安全的 TypeOf”。它解决的是另一类问题：当类型参数本来就明确时，避免用 new(T)、零值或指针技巧制造一个只为取类型而存在的值。

nil、指针和接口类型为什么会产生不同键

TypeFor[*User] 与 TypeFor[User] 不相等

注册表如果注册的是 User，查找时传入 &User{} 就不会命中，因为 reflect.Type 记录了指针层级。要么统一注册和值的形态，要么明确写两条注册记录；不要在查找函数里悄悄 Elem()，那会把指针语义吞掉。

TypeOf(nil) 没有类型可以返回

一个 nil 接口里没有动态类型，所以 reflect.TypeOf(nil) 得到的是 nil。上面的 Find 先判断 value == nil，这不是多余防御，而是避免把 nil 当成 map 键后又继续对空类型做判断。

TypeFor[any] 取得的是接口类型

reflect.TypeFor[any]() 描述的是接口类型 any。它不会因为某次调用传入了 UserCreated 就变成结构体类型；动态值的具体类型仍由 TypeOf 决定。

把缓存键固定下来，再做一次边界验收

实践中我会把注册函数限制在“类型参数已知”的入口，把查找函数限制在“值已经到达”的入口。这样缓存键的来源一眼可见，也不会因为后续有人把指针消息塞进来而误以为它和非指针消息等价。

func typeName[T any]() string {
    return reflect.TypeFor[T]().String()
}

fmt.Println(typeName[UserCreated]()) // main.UserCreated
fmt.Println(typeName[*UserCreated]()) // *main.UserCreated

var nothing any
fmt.Println(reflect.TypeOf(nothing) == nil) // true
fmt.Println(reflect.TypeFor[any]().Kind() == reflect.Interface) // true

测试时至少覆盖值、指针、命名类型和 nil 四条路径。若类型注册表还要支持别名策略，请把归一化规则写在注册和查找两侧，并在文档里说明；不要把 Elem() 当成默认修复。

常见问题

TypeFor 需要先创建一个 T 的实例吗？

不需要。它直接根据类型参数返回 reflect.Type，这正是它相比零值或 new(T) 取类型写法的价值。

运行时拿到 interface{} 时还能用 TypeFor 吗？

如果目标类型只有在运行时才知道，应使用 reflect.TypeOf(value)；只有调用方已经把具体类型作为 T 传入时，才适合用 TypeFor。

为什么 TypeFor[*User] 查不到 User 的处理器？

指针类型和结构体值类型是两个不同的 reflect.Type。统一消息形态，或分别注册两个键，取决于你的业务协议。

TypeOf(nil) 返回什么？

返回 nil，因为 nil 接口没有动态类型。查找注册表前应先判断这一分支。

把选择规则留在代码入口处

判断标准可以压缩成一句话：手里有类型参数，用 TypeFor；手里只有运行时值，用 TypeOf。注册表再复杂，也应让这两个入口保持清晰。这样 nil 不会被误当成具体类型，指针也不会在不知不觉中改变分派结果。