深入理解Go语言中嵌套JSON结构的遍历与类型断言

{
    "tg": {
        "A": {
            "E": 100,
            "H": 14
        },
        "B": {
            "D": 1
        },
        "C": {
            "D": 1,
            "E": 1
        },
        "D": {
            "F": 1,
            "G": 1,
            "H": 1
        },
        "E": {
            "G": 1
        }
    }
}

package main

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

// 假设我们有一个JSON包装器，这里简化模拟其行为
// 实际中可能是第三方库如gabs等
type JSON struct {
    data interface{}
}

func (j *JSON) Get(key string) *JSON {
    if m, ok := j.data.(map[string]interface{}); ok {
        if val, exists := m[key]; exists {
            return &JSON{data: val}
        }
    }
    return &JSON{data: nil} // Key not found
}

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

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

    // 模拟 js.Get 的起始点
    js := &JSON{data: rawData}

    // 访问 "tg.D.F"
    a := js.Get("tg").Get("D").Get("F")

    // 打印 a 的详细类型和值
    fmt.Printf("变量 a 的类型和值: %#v\n", a) // 预期输出: &main.JSON{data:1}

    // 访问 a 结构体内部的实际数据字段 (a.data)
    // 打印 a.data 的反射类型
    fmt.Println("a.data 的类型:", reflect.TypeOf(a.data)) // 预期输出: float64

    // 正确的类型断言和转换
    // 1. 断言 a.data 为 float64
    // 2. 将 float64 转换为 int
    if valFloat, ok := a.data.(float64); ok {
        x := int(valFloat)
        fmt.Println("提取到的整数值 x:", x) // 预期输出: 1
    } else {
        fmt.Println("无法将 a.data 断言为 float64")
    }
}

package main

import (
    "encoding/json"
    "fmt"
)

// traverseJSON 递归遍历 interface{} 类型的 JSON 数据
// path 用于构建当前元素的路径，方便识别
func traverseJSON(data interface{}, path string) {
    switch v := data.(type) {
    case map[string]interface{}:
        // 如果是 map，遍历其键值对
        for key, value := range v {
            currentPath := path
            if currentPath != "" {
                currentPath += "."
            }
            currentPath += key
            traverseJSON(value, currentPath) // 递归处理值
        }
    case []interface{}:
        // 如果是数组，遍历其元素
        for i, item := range v {
            currentPath := fmt.Sprintf("%s[%d]", path, i)
            traverseJSON(item, currentPath) // 递归处理元素
        }
    case float64:
        // 如果是 float64 (JSON数字默认类型)，可以将其转换为 int
        intValue := int(v)
        fmt.Printf("路径: %s, 原始值(float64): %f, 转换为整数: %d\n", path, v, intValue)
    case string:
        fmt.Printf("路径: %s, 字符串值: %s\n", path, v)
    case bool:
        fmt.Printf("路径: %s, 布尔值: %t\n", path, v)
    case nil:
        fmt.Printf("路径: %s, 空值: nil\n", path)
    default:
        fmt.Printf("路径: %s, 未知类型: %T, 值: %v\n", path, 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": [10, "hello", {"item": 20}]
        }
    }`

    var result interface{}
    err := json.Unmarshal([]byte(jsonStr), &result)
    if err != nil {
        fmt.Println("JSON反序列化失败:", err)
        return
    }

    fmt.Println("开始递归遍历JSON结构:")
    traverseJSON(result, "")
}