Go 语言中利用反射机制打印结构体成员信息

package main

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

// PrettyPrint 递归地打印Go语言中任意对象的结构和值
func PrettyPrint(obj interface{}) {
    prettyPrintRecursive(reflect.ValueOf(obj), 0)
}

func prettyPrintRecursive(v reflect.Value, indent int) {
    // 处理空值
    if !v.IsValid() {
        fmt.Printf("%s<nil>\n", strings.Repeat("  ", indent))
        return
    }

    // 如果是指针，则解引用
    if v.Kind() == reflect.Ptr {
        if v.IsNil() {
            fmt.Printf("%s<nil>\n", strings.Repeat("  ", indent))
            return
        }
        prettyPrintRecursive(v.Elem(), indent)
        return
    }

    // 获取类型信息
    t := v.Type()

    switch v.Kind() {
    case reflect.Struct:
        fmt.Printf("%s%s {\n", strings.Repeat("  ", indent), t.Name())
        for i := 0; i < v.NumField(); i++ {
            field := v.Field(i)
            fieldType := t.Field(i)

            // 检查字段是否可导出 (首字母大写)
            if !fieldType.IsExported() {
                // 对于不可导出字段，我们只能打印其名称，无法获取其值或进一步遍历
                fmt.Printf("%s  %s: <unexported>\n", strings.Repeat("  ", indent), fieldType.Name)
                continue
            }

            fmt.Printf("%s  %s: ", strings.Repeat("  ", indent), fieldType.Name)
            // 递归处理嵌套结构体、切片或映射
            prettyPrintRecursive(field, indent+1)
        }
        fmt.Printf("%s}\n", strings.Repeat("  ", indent))

    case reflect.Slice, reflect.Array:
        fmt.Printf("%s%s [\n", strings.Repeat("  ", indent), t.Name())
        for i := 0; i < v.Len(); i++ {
            fmt.Printf("%s  [%d]: ", strings.Repeat("  ", indent), i)
            prettyPrintRecursive(v.Index(i), indent+1)
        }
        fmt.Printf("%s]\n", strings.Repeat("  ", indent))

    case reflect.Map:
        fmt.Printf("%s%s {\n", strings.Repeat("  ", indent), t.Name())
        for _, key := range v.MapKeys() {
            fmt.Printf("%s  %v: ", strings.Repeat("  ", indent), key.Interface())
            prettyPrintRecursive(v.MapIndex(key), indent+1)
        }
        fmt.Printf("%s}\n", strings.Repeat("  ", indent))

    default:
        // 打印基本类型的值
        fmt.Printf("%v (type %s)\n", v.Interface(), t.Name())
    }
}

// 定义一些示例结构体
type Address struct {
    Street string
    City   string
    Zip    string
}

type Person struct {
    Name    string
    Age     int
    IsAdult bool
    Address Address
    Hobbies []string
    Meta    map[string]interface{}
    secret  string // 非导出字段
}

func main() {
    p := Person{
        Name:    "Alice",
        Age:     30,
        IsAdult: true,
        Address: Address{
            Street: "123 Main St",
            City:   "Anytown",
            Zip:    "12345",
        },
        Hobbies: []string{"Reading", "Coding", "Hiking"},
        Meta: map[string]interface{}{
            "Occupation": "Engineer",
            "Active":     true,
            "Score":      99.5,
        },
        secret: "top_secret_info", // 非导出字段的值
    }

    fmt.Println("--- Printing Person object ---")
    PrettyPrint(p)

    fmt.Println("\n--- Printing pointer to Person object ---")
    PrettyPrint(&p)

    // 打印一个切片
    fmt.Println("\n--- Printing a slice ---")
    mySlice := []int{10, 20, 30}
    PrettyPrint(mySlice)

    // 打印一个映射
    fmt.Println("\n--- Printing a map ---")
    myMap := map[string]string{"key1": "value1", "key2": "value2"}
    PrettyPrint(myMap)

    // 打印基本类型（虽然不常用，但反射也能处理）
    fmt.Println("\n--- Printing a string ---")
    PrettyPrint("Hello, Go Reflection!")
}