Go语言中嵌套JSON结构的深度遍历与类型安全提取

{
    "value": 1
}

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    jsonStr := `{"value": 1}`
    var data interface{}
    err := json.Unmarshal([]byte(jsonStr), &data)
    if err != nil {
        fmt.Println("Error unmarshaling:", err)
        return
    }

    // 假设我们知道data是一个map
    m := data.(map[string]interface{})
    val := m["value"]

    // 错误示例：直接断言为int
    // i := val.(int) // 这会导致运行时错误：panic: interface conversion: interface {} is float64, not int
    // fmt.Println(i)

    // 正确的做法：先断言为float64，再转换为int
    if f, ok := val.(float64); ok {
        i := int(f)
        fmt.Printf("Extracted integer: %d, Type: %T\n", i, i) // Output: Extracted integer: 1, Type: int
    } else {
        fmt.Printf("Value is not a float64, actual type: %T\n", val)
    }
}

package main

import (
    "encoding/json"
    "fmt"
    "reflect" // 用于调试和类型检查
)

// traverseJSON 递归遍历嵌套的JSON结构
// data: 当前要遍历的数据片段 (interface{})
// path: 当前数据片段在整个JSON结构中的路径，用于追踪位置
func traverseJSON(data interface{}, path string) {
    switch v := data.(type) {
    case map[string]interface{}:
        // 如果是JSON对象，遍历其键值对
        fmt.Printf("Path: %s, Type: object\n", path)
        for key, value := range v {
            newPath := fmt.Sprintf("%s.%s", path, key)
            traverseJSON(value, newPath) // 递归处理每个值
        }
    case []interface{}:
        // 如果是JSON数组，遍历其元素
        fmt.Printf("Path: %s, Type: array\n", path)
        for i, item := range v {
            newPath := fmt.Sprintf("%s[%d]", path, i)
            traverseJSON(item, newPath) // 递归处理每个元素
        }
    case float64:
        // 如果是float64（JSON数字），可以根据需要转换为int
        intValue := int(v)
        fmt.Printf("Path: %s, Type: float64 (converted to int: %d), Value: %.2f\n", path, intValue, v)
    case string:
        // 如果是字符串
        fmt.Printf("Path: %s, Type: string, Value: %s\n", path, v)
    case bool:
        // 如果是布尔值
        fmt.Printf("Path: %s, Type: bool, Value: %t\n", path, v)
    case nil:
        // 如果是null
        fmt.Printf("Path: %s, Type: null, Value: nil\v", path)
    default:
        // 处理其他未知类型，例如，如果JSON中有非标准类型或解析错误
        fmt.Printf("Path: %s, Type: %s (unhandled), Value: %#v\n", path, reflect.TypeOf(v), v)
    }
}

func main() {
    jsonString := `{
        "tg": {
            "A": {
                "E": 100,
                "H": 14
            },
            "B": {
                "D": 1
            },
            "C": {
                "D": 1,
                "E": 1
            },
            "D": {
                "F": 1,
                "G": 1,
                "H": 1
            },
            "E": {
                "G": 1
            },
            "ArrayExample": [10, "hello", {"nested": 20}]
        }
    }`

    var result map[string]interface{}
    err := json.Unmarshal([]byte(jsonString), &result)
    if err != nil {
        fmt.Println("Error unmarshaling JSON:", err)
        return
    }

    fmt.Println("--- Starting JSON Traversal ---")
    traverseJSON(result, "root")
    fmt.Println("--- JSON Traversal Complete ---")
}