答案：通过reflect包实现通用打印函数，利用TypeOf和ValueOf获取类型和值信息，结合Kind判断基础类型并格式化输出，支持结构体与切片的递归处理，并可通过结构体标签控制字段显示，适用于日志、序列化等场景。

在 Golang 中，虽然类型系统是静态的，但通过反射（reflect 包）可以实现运行时动态访问变量的类型和值。这使得我们能够编写通用的打印函数，适用于任意类型的输入，并根据类型特征进行格式化输出。

理解 reflect.Type 和 reflect.Value

要实现通用打印，首先要掌握 reflect.TypeOf 和 reflect.ValueOf 的使用：

• reflect.TypeOf(v) 返回变量 v 的类型信息（reflect.Type）
• reflect.ValueOf(v) 返回变量 v 的值信息（reflect.Value）
• 通过 Kind() 方法可获取底层数据类型（如 int、string、struct 等）

例如：

var x int = 42
t := reflect.TypeOf(x)      // t.Name() == "int"
v := reflect.ValueOf(x)     // v.Kind() == reflect.Int

构建通用打印函数的基本结构

我们可以定义一个函数，接收 interface{} 类型参数，再通过反射判断其具体类型并输出：

func PrintGeneric(v interface{}) {
    val := reflect.ValueOf(v)
    typ := reflect.TypeOf(v)

    switch val.Kind() {
    case reflect.String:
        fmt.Printf("字符串: %q\n", val.String())
    case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
        fmt.Printf("整数: %d\n", val.Int())
    case reflect.Float32, reflect.Float64:
        fmt.Printf("浮点数: %.2f\n", val.Float())
    case reflect.Bool:
        fmt.Printf("布尔值: %t\n", val.Bool())
    default:
        fmt.Printf("未知类型 [%s]: %v\n", typ, v)
    }
}

这样就能对基础类型做差异化输出，比如数字保留小数位，字符串加引号等。

处理复杂类型：结构体与切片

对于 struct 和 slice，需要递归或遍历处理内部元素：

• 如果是结构体（val.Kind() == reflect.Struct），可用 Field(i) 获取字段值，Type.Field(i).Name 获取字段名
• 如果是切片或数组，可用 Len() 遍历每个元素，递归调用自身打印

示例片段：

case reflect.Slice:
    fmt.Print("切片 [")
    for i := 0; i < val.Len(); i++ {
        if i > 0 { fmt.Print(", ") }
        PrintGeneric(val.Index(i).Interface())
    }
    fmt.Println("]")
case reflect.Struct:
    fmt.Printf("结构体 %s {\n", typ.Name())
    for i := 0; i < val.NumField(); i++ {
        field := typ.Field(i)
        value := val.Field(i)
        fmt.Printf("  %s: ", field.Name)
        PrintGeneric(value.Interface())
    }
    fmt.Println("}")

结合标签控制输出格式

利用结构体标签（tag），可以在运行时决定如何显示字段。例如定义一个 json 或 display 标签来控制是否隐藏某些字段：

type Person struct {
    Name string `display:"show"`
    Age  int    `display:"hide"`
}

在反射中读取标签：

tag := typ.Field(i).Tag.Get("display")
if tag == "hide" {
    continue // 跳过该字段
}

这样就实现了基于元信息的条件输出，增强通用性与灵活性。

基本上就这些。Golang 反射虽不如动态语言灵活，但足以支持通用打印、序列化、日志记录等场景。关键是合理使用 Kind 判断类型，结合 Value.Interface() 还原数据，再按需格式化输出。注意性能敏感场景慎用反射，但在工具类函数中非常实用。