Go语言中动态构建JSON结构的现代方法与实践

go get github.com/Jeffail/gabs

package main

import (
    "fmt"
    "github.com/Jeffail/gabs/v2" // 注意这里使用了v2版本
)

func main() {
    // 1. 创建一个新的gabs JSON对象
    jsonObj := gabs.New()

    // 2. 使用 Set 方法设置值
    // Set(value interface{}, path ...string)
    // path参数指定了值在JSON中的位置，如果路径不存在，gabs会自动创建
    jsonObj.Set(10, "outer", "inner", "value")
    // 等价于 {"outer":{"inner":{"value":10}}}

    // 3. 使用 SetP 方法设置值 (P for Path)
    // SetP(value interface{}, path string)
    // path参数是一个点分字符串，更简洁地指定路径
    jsonObj.SetP(20, "outer.inner.value2")
    // 等价于 {"outer":{"inner":{"value":10,"value2":20}}}

    // 4. 设置另一个路径下的值
    jsonObj.Set(30, "outer", "inner2", "value3")
    // 等价于 {"outer":{"inner":{"value":10,"value2":20},"inner2":{"value3":30}}}

    // 5. 添加一个数组元素
    // Append(value interface{}, path ...string)
    jsonObj.ArrayAppend("apple", "groceries")
    jsonObj.ArrayAppend("banana", "groceries")
    jsonObj.ArrayAppend("milk", "groceries")
    // 等价于 {"groceries":["apple","banana","milk"], ...}

    // 6. 在嵌套路径中添加数组元素
    jsonObj.ArrayAppend(map[string]interface{}{"item": "book", "price": 15.99}, "cart", "items")
    jsonObj.ArrayAppend(map[string]interface{}{"item": "pen", "price": 2.50}, "cart", "items")
    // 等价于 {"cart":{"items":[{"item":"book","price":15.99},{"item":"pen","price":2.5}]}}

    // 7. 获取JSON字符串表示
    fmt.Println("构建的JSON:")
    fmt.Println(jsonObj.String())

    // 8. 从现有JSON字符串解析
    jsonString := `{"data":{"items":[{"id":1,"name":"A"},{"id":2,"name":"B"}]}}`
    parsedJson, err := gabs.ParseJSON([]byte(jsonString))
    if err != nil {
        fmt.Println("解析JSON失败:", err)
        return
    }

    // 9. 读取JSON中的值
    nameB := parsedJson.Path("data.items.1.name").Data() // 获取第二个item的name
    fmt.Println("\n读取到的name:", nameB) // 输出: B

    // 10. 修改JSON中的值
    parsedJson.Set("C", "data", "items", "0", "name") // 修改第一个item的name
    fmt.Println("\n修改后的JSON:")
    fmt.Println(parsedJson.String())
}

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    // 创建一个根级别的map
    dynamicJSON := make(map[string]interface{})

    // 设置基本键值对
    dynamicJSON["hello"] = "world"
    dynamicJSON["age"] = 30
    dynamicJSON["isStudent"] = false

    // 创建一个嵌套的map
    address := make(map[string]interface{})
    address["street"] = "123 Main St"
    address["city"] = "Anytown"
    address["zip"] = "12345"
    dynamicJSON["address"] = address

    // 创建一个数组
    groceries := []string{"Eggs", "Bread", "Milk"}
    dynamicJSON["groceries"] = groceries

    // 创建一个包含复杂对象的数组
    items := []interface{}{
        map[string]interface{}{"id": 1, "name": "Laptop", "price": 1200.0},
        map[string]interface{}{"id": 2, "name": "Mouse", "price": 25.0},
    }
    dynamicJSON["items"] = items

    // 将map序列化为JSON字符串
    jsonData, err := json.MarshalIndent(dynamicJSON, "", "  ") // 使用MarshalIndent美化输出
    if err != nil {
        fmt.Println("序列化JSON失败:", err)
        return
    }

    fmt.Println(string(jsonData))

    // 反序列化回map[string]interface{}
    var parsedMap map[string]interface{}
    err = json.Unmarshal(jsonData, &parsedMap)
    if err != nil {
        fmt.Println("反序列化JSON失败:", err)
        return
    }

    fmt.Println("\n反序列化后的数据:")
    fmt.Println("Hello:", parsedMap["hello"])
    // 访问嵌套数据需要类型断言
    if addr, ok := parsedMap["address"].(map[string]interface{}); ok {
        fmt.Println("City:", addr["city"])
    }
}