Go语言中嵌套JSON结构体的遍历与数值类型断言

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
)

// JSON 辅助结构体，用于简化嵌套JSON的访问
// 实际应用中，这可能是一个更复杂的库或自定义实现
type JSON struct {
    data interface{}
}

// Get 方法模拟访问JSON对象的子字段
func (j *JSON) Get(key string) *JSON {
    if m, ok := j.data.(map[string]interface{}); ok {
        if val, found := m[key]; found {
            return &JSON{data: val}
        }
    }
    return &JSON{data: nil} // 如果找不到或类型不匹配，返回nil
}

func main() {
    jsonStr := `{
        "tg": {
            "A": { "E": 100, "H": 14 },
            "B": { "D": 1 },
            "C": { "D": 1, "E": 1 },
            "D": { "F": 1, "G": 1, "H": 1 },
            "E": { "G": 1 }
        }
    }`

    var rawData interface{}
    err := json.Unmarshal([]byte(jsonStr), &rawData)
    if err != nil {
        fmt.Println("Error unmarshalling JSON:", err)
        return
    }

    // 初始化我们的JSON辅助结构体
    js := &JSON{data: rawData}

    // 尝试访问嵌套值
    a := js.Get("tg").Get("D").Get("F")

    // 打印a的类型，会发现它是一个指向JSON结构体的指针
    fmt.Printf("变量 'a' 的类型: %#v\n", a) // 输出: &main.JSON{data:1}

    // 打印a所封装的数据(a.data)的实际类型
    // 这揭示了JSON数字被解析为float64的事实
    if a != nil && a.data != nil {
        fmt.Println("'a.data' 的实际类型:", reflect.TypeOf(a.data)) // 输出: float64
    }

    // 错误的类型断言尝试 (会导致运行时错误)
    // x := (*a).(int) // 错误：invalid type assertion: (*a).(int)

    // 正确的类型断言和转换方法
    if a != nil && a.data != nil {
        if valFloat, ok := a.data.(float64); ok {
            x := int(valFloat) // 先断言为float64，再转换为int
            fmt.Println("成功提取的整数值:", x)
        } else {
            fmt.Printf("错误：'a.data' 不是 float64 类型，而是 %T\n", a.data)
        }
    }
}

package main

import (
    "encoding/json"
    "fmt"
    "reflect"
)

// traverseJSON 递归函数，用于遍历并打印JSON中的所有键值对
// data: 当前要遍历的数据
// prefix: 当前路径前缀，用于表示嵌套层级
func traverseJSON(data interface{}, prefix string) {
    switch v := data.(type) {
    case map[string]interface{}:
        // 如果是JSON对象，则遍历其键值对
        for key, val := range v {
            newPrefix := prefix
            if newPrefix != "" {
                newPrefix += "."
            }
            newPrefix += key
            // 递归调用自身处理子元素
            traverseJSON(val, newPrefix)
        }
    case []interface{}:
        // 如果是JSON数组，则遍历其元素
        for i, val := range v {
            newPrefix := fmt.Sprintf("%s[%d]", prefix, i)
            // 递归调用自身处理子元素
            traverseJSON(val, newPrefix)
        }
    case float64:
        // 处理JSON数字，它们被解析为float64
        // 可以根据需要转换为int或保持float64
        fmt.Printf("路径: %s, 类型: float64, 值: %v (转换为int: %d)\n", prefix, v, int(v))
    case string:
        // 处理JSON字符串
        fmt.Printf("路径: %s, 类型: string, 值: \"%s\"\n", prefix, v)
    case bool:
        // 处理JSON布尔值
        fmt.Printf("路径: %s, 类型: bool, 值: %t\n", prefix, v)
    case nil:
        // 处理JSON空值
        fmt.Printf("路径: %s, 类型: nil, 值: null\n", prefix)
    default:
        // 处理其他未知类型
        fmt.Printf("路径: %s, 类型: %T, 值: %v (未知类型)\n", prefix, v, v)
    }
}

func main() {
    jsonStr := `{
        "tg": {
            "A": { "E": 100, "H": 14 },
            "B": { "D": 1 },
            "C": { "D": 1, "E": 1 },
            "D": { "F": 1, "G": 1, "H": 1 },
            "E": { "G": 1 },
            "list_example": [1, 2, "hello", true, null, {"nested_obj": 99.5}]
        },
        "version": "1.0",
        "active": true
    }`

    var rawData interface{}
    err := json.Unmarshal([]byte(jsonStr), &rawData)
    if err != nil {
        fmt.Println("Error unmarshalling JSON:", err)
        return
    }

    fmt.Println("--- 完整递归遍历JSON结构 ---")
    traverseJSON(rawData, "")
}