Go语言中解析JSON时保留64位整型值的策略

package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "strconv"
)

func main() {
    body := []byte(`{"tags":[{"id":4418489049307132905},{"id":4418489049307132906}]}`)

    // 使用map[string]interface{}来存储解析结果
    dat := make(map[string]interface{})

    // 创建json.Decoder实例
    d := json.NewDecoder(bytes.NewBuffer(body))

    // 启用UseNumber()，将所有数字解析为json.Number类型
    d.UseNumber()

    if err := d.Decode(&dat); err != nil {
        panic(err)
    }

    // 提取tags数组
    tags, ok := dat["tags"].([]interface{})
    if !ok {
        panic("tags is not an array")
    }

    for i, tag := range tags {
        tagMap, ok := tag.(map[string]interface{})
        if !ok {
            fmt.Printf("tag %d is not a map\n", i)
            continue
        }

        // 获取id字段，此时它将是json.Number类型
        idNumber, ok := tagMap["id"].(json.Number)
        if !ok {
            fmt.Printf("tag %d id is not a json.Number\n", i)
            continue
        }

        // 将json.Number转换为uint64
        // 如果是负数，应使用strconv.ParseInt
        i64, err := strconv.ParseUint(string(idNumber), 10, 64)
        if err != nil {
            fmt.Printf("Error parsing id %s: %v\n", idNumber, err)
            continue
        }
        fmt.Printf("tag: %d id: %d (Type: %T)\n", i, i64, i64)
    }
}

package main

import (
    "encoding/json"
    "fmt"
)

// 定义与JSON结构对应的Go结构体
type Tag struct {
    ID uint64 `json:"id"` // 明确指定ID为uint64类型
}

type Payload struct {
    Tags []Tag `json:"tags"` // 包含Tag结构体切片
}

func main() {
    body := []byte(`{"tags":[{"id":4418489049307132905},{"id":4418489049307132906}]}`)

    var payload Payload

    // 直接解码到定义好的结构体
    if err := json.Unmarshal(body, &payload); err != nil {
        panic(err)
    }

    for i, tag := range payload.Tags {
        fmt.Printf("tag: %d id: %d (Type: %T)\n", i, tag.ID, tag.ID)
    }
}