Go语言JSON解析深度指南：应对嵌套数据与类型安全

{
  "id" : "12387",
  "inv" :[
    {
      "qty" : 5,
       "seq" : 2,
       "invIs" : "1HG9876",
       "addCharges" :[
         {
          "amnt" : 24,
          "char" : "REI",
          "type" : "MT"
          },
          {
          "amnt" : 12,
          "char" : "REI",
          "type" : "MT"
          }
        ],
      "seq" : 3
    },
    {
      "qty" : 5,
       "seq" : 2,
       "invIs" : "1HG9876",
       "addCharges" :[
         {
          "amnt" : 64,
          "char" : "REI",
          "type" : "MT"
          },
          {
          "amnt" : 36,
          "char" : "REI",
          "type" : "MT"
          }
        ],
      "seq" : 3
    }
  ],
    "charges" : {
      "fee" : 24 ,
      "bkg" : 7676
    }
}

package main

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

// Product 对应顶层JSON对象
type Product struct {
    Id      string `json:"id"`
    Items   []Item `json:"inv"`
    Charges Charge `json:"charges"` // 修正：charges是顶层对象，且为单个Charge结构体
}

// Item 对应 "inv" 数组中的每个元素
type Item struct {
    Quantity   int         `json:"qty"`
    Sequence   int         `json:"seq"` // 注意：原始JSON中"seq"字段重复出现，Go Unmarshal通常会取最后一个值
    Inventory  string      `json:"invIs"`
    AddCharges []AddCharge `json:"addCharges"`
    // 原始JSON中"charges"不在Item层级，故此处不定义
}

// Charge 对应顶层 "charges" 对象
type Charge struct {
    Fee int `json:"fee"`
    Bkg int `json:"bkg"`
}

// AddCharge 对应 "addCharges" 数组中的每个元素
type AddCharge struct {
    Amount int    `json:"amnt"`
    Char   string `json:"char"`
    Type   string `json:"type"`
}

const jsonString = `{
  "id" : "12387",
  "inv" :[
    {
      "qty" : 5,
       "seq" : 2,
       "invIs" : "1HG9876",
       "addCharges" :[
         {
          "amnt" : 24,
          "char" : "REI",
          "type" : "MT"
          },
          {
          "amnt" : 12,
          "char" : "REI",
          "type" : "MT"
          }
        ],
      "seq" : 3
    },
    {
      "qty" : 5,
       "seq" : 2,
       "invIs" : "1HG9876",
       "addCharges" :[
         {
          "amnt" : 64,
          "char" : "REI",
          "type" : "MT"
          },
          {
          "amnt" : 36,
          "char" : "REI",
          "type" : "MT"
          }
        ],
      "seq" : 3
    }
  ],
    "charges" : {
      "fee" : 24 ,
      "bkg" : 7676
    }
}`

// findAddCharges 查找所有AddCharge实例并以切片形式返回。
func findAddCharges() ([]AddCharge, error) {
    var prod Product // 声明一个Product类型的变量来存储解析后的数据

    data := []byte(jsonString) // 将JSON字符串转换为字节切片
    err := json.Unmarshal(data, &prod) // 解析JSON
    if err != nil {
        return nil, fmt.Errorf("解析JSON失败: %w", err)
    }

    var allAddCharges []AddCharge // 用于收集所有AddCharge的切片

    // 遍历所有Item，并将每个Item中的AddCharges添加到allAddCharges切片中
    for _, item := range prod.Items {
        allAddCharges = append(allAddCharges, item.AddCharges...)
    }

    return allAddCharges, nil
}

func main() {
    charges, err := findAddCharges()
    if err != nil {
        fmt.Fprintf(os.Stderr, "错误: %v\n", err)
        os.Exit(1)
    }

    // 打印提取到的所有附加费用
    fmt.Println("提取到的所有附加费用:")
    for _, c := range charges {
        fmt.Printf(" %+v\n", c)
    }

    // 如果我们只关心amnt字段，可以进一步处理
    var amntValues []map[string]int
    for _, c := range charges {
        amntValues = append(amntValues, map[string]int{"amnt": c.Amount})
    }
    fmt.Println("\n提取到的所有 'amnt' 字段:")
    fmt.Printf("%+v\n", amntValues)
}

提取到的所有附加费用:
 {Amount:24 Char:REI Type:MT}
 {Amount:12 Char:REI Type:MT}
 {Amount:64 Char:REI Type:MT}
 {Amount:36 Char:REI Type:MT}

提取到的所有 'amnt' 字段:
[map[amnt:24] map[amnt:12] map[amnt:64] map[amnt:36]]

// 原始问题中尝试的动态解析片段
var j map[string]interface{}
err := json.Unmarshal([]byte(ticket), &j)
if err != nil {
    panic(err)
}

// 提取 "inv" 字段
bytInv := j["inv"].([]interface{}) // 这里需要进行类型断言

// 后续处理会变得复杂：
// for _, itemIface := range bytInv {
//     itemMap := itemIface.(map[string]interface{}) // 再次类型断言
//     addChargesIface := itemMap["addCharges"].([]interface{}) // 继续类型断言
//     for _, chargeIface := range addChargesIface {
//         chargeMap := chargeIface.(map[string]interface{}) // 再次类型断言
//         amnt := chargeMap["amnt"].(float64) // 最终提取值，数字通常会被解析为float64
//         // ... 收集 amnt
//     }
// }

{
  "qty" : 5,
   "seq" : 2,      // 第一次出现
   "invIs" : "1HG9876",
   "addCharges" : [...],
  "seq" : 3       // 第二次出现
}