Go语言教程：如何根据条件筛选JSON对象数组

[
    {
        "seq" : 2,
        "amnt" : 125
    },
    {
        "seq" : 3,
        "amnt" : 25
    },
    {
        "seq" : 2,
        "amnt" : 250
    }
]

package main

import (
    "encoding/json"
    "fmt"
)

// 定义原始JSON数据
const jsonData = `[
    {"seq": 2, "amnt": 125},
    {"seq": 3, "amnt": 25},
    {"seq": 2, "amnt": 250},
    {"seq": 1, "amnt": 50}
]`

func main() {
    // 1. 将JSON字符串反序列化为 []map[string]int 切片
    // 注意：如果JSON中包含非int类型的值，此处的Unmarshal会失败
    var dataSlice []map[string]int
    err := json.Unmarshal([]byte(jsonData), &dataSlice)
    if err != nil {
        fmt.Printf("JSON Unmarshal failed: %v\n", err)
        return
    }

    // 2. 遍历切片，根据条件筛选数据
    var filteredResults []map[string]int
    for _, item := range dataSlice {
        // 检查 "seq" 字段是否存在且其值为 2
        // ok 变量用于判断键是否存在，避免访问不存在的键导致panic
        if seq, ok := item["seq"]; ok && seq == 2 {
            filteredResults = append(filteredResults, item)
        }
    }

    // 3. 打印筛选结果
    fmt.Println("筛选结果 (seq == 2):")
    for _, result := range filteredResults {
        fmt.Printf("  %+v\n", result)
    }

    fmt.Println("\n--- 另一种情况：使用 map[string]interface{} 处理混合类型 ---")
    // 示例：如果JSON中包含其他类型（如字符串），则需要使用 map[string]interface{}
    const mixedJsonData = `[{"seq": 2, "name": "Alice", "amnt": 100}, {"seq": 3, "name": "Bob", "amnt": 200}]`
    var mixedDataSlice []map[string]interface{}
    err = json.Unmarshal([]byte(mixedJsonData), &mixedDataSlice)
    if err != nil {
        fmt.Printf("Mixed JSON Unmarshal failed: %v\n", err)
        return
    }

    var filteredMixedResults []map[string]interface{}
    for _, item := range mixedDataSlice {
        // JSON数字默认解析为 float64，因此需要进行类型断言
        if seqVal, ok := item["seq"].(float64); ok && seqVal == 2 {
            filteredMixedResults = append(filteredMixedResults, item)
        }
    }
    fmt.Println("筛选结果 (seq == 2) - 使用 map[string]interface{}:")
    for _, result := range filteredMixedResults {
        fmt.Printf("  %+v\n", result)
    }
}

package main

import (
    "encoding/json"
    "fmt"
)

// 定义与JSON对象结构对应的Go结构体
type Item struct {
    Seq  int `json:"seq"`  // 映射JSON的"seq"字段到Go的Seq字段
    Amnt int `json:"amnt"` // 映射JSON的"amnt"字段到Go的Amnt字段
    // 如果JSON有更多字段，可以在这里添加，并使用json标签进行映射
    // 例如: Name string `json:"name"`
}

// 原始JSON数据
const jsonDataWithStruct = `[
    {"seq": 2, "amnt": 125},
    {"seq": 3, "amnt": 25},
    {"seq": 2, "amnt": 250},
    {"seq": 1, "amnt": 50}
]`

func main() {
    // 1. 将JSON字符串反序列化为 []Item 切片
    var items []Item
    err := json.Unmarshal([]byte(jsonDataWithStruct), &items)
    if err != nil {
        fmt.Printf("JSON Unmarshal to struct failed: %v\n", err)
        return
    }

    // 2. 遍历切片，根据条件筛选数据
    var filteredItems []Item
    for _, item := range items {
        if item.Seq == 2 { // 直接通过结构体字段访问，类型安全
            filteredItems = append(filteredItems, item)
        }
    }

    // 3. 打印筛选结果
    fmt.Println("筛选结果 (seq == 2) - 使用结构体:")
    for _, result := range filteredItems {
        fmt.Printf("  %+v\n", result)
    }
}