Golang中如何精确处理JSON大整数：json.Number的应用

{
    "id": 12423434,
    "Name": "Fernando"
}

package main

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

func main() {
    // 原始JSON字符串
    jsonString := []byte(`
        {
        "id": 12423434,
        "Name": "Fernando"
        }
    `)

    // 解码到 interface{}
    var data interface{}
    err := json.Unmarshal(jsonString, &data)
    if err != nil {
        fmt.Printf("Unmarshal error: %v\n", err)
        return
    }

    // 此时 data 中的数字字段已是 float64 类型
    // 打印解码后的 map
    if m, ok := data.(map[string]interface{}); ok {
        fmt.Printf("解码后的Map: %v\n", m)
    }

    // 再次编码回JSON字符串
    result, err := json.Marshal(data)
    if err != nil {
        fmt.Printf("Marshal error: %v\n", err)
        return
    }

    // 打印结果，id 字段变为浮点数表示
    fmt.Printf("再次编码后的JSON: %s\n", result)
}

解码后的Map: map[Name:Fernando id:1.2423434e+07]
再次编码后的JSON: {"Name":"Fernando","id":1.2423434e+07}

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "strings"
)

func main() {
    jsonString := `{
        "id": 12423434,
        "Name": "Fernando",
        "large_id": 9223372036854775807,
        "pi": 3.1415926535
    }`

    // 创建一个 json.Decoder
    decoder := json.NewDecoder(strings.NewReader(jsonString))

    // 调用 UseNumber() 方法，指示解码器将所有数字解析为 json.Number
    decoder.UseNumber()

    var data interface{}
    if err := decoder.Decode(&data); err != nil {
        log.Fatalf("解码失败: %v", err)
    }

    // 打印解码后的数据，此时数字字段为 json.Number 类型
    fmt.Printf("解码后的数据类型: %#v\n", data)

    // 遍历 map，检查数字类型
    if m, ok := data.(map[string]interface{}); ok {
        for k, v := range m {
            if num, isNumber := v.(json.Number); isNumber {
                fmt.Printf("字段 '%s' 是 json.Number 类型，值为: %s\n", k, num)
                // 可以根据需要转换为 int64 或 float64
                if i, err := num.Int64(); err == nil {
                    fmt.Printf("  -> 转换为 int64: %d\n", i)
                }
                if f, err := num.Float64(); err == nil {
                    fmt.Printf("  -> 转换为 float64: %f\n", f)
                }
            } else {
                fmt.Printf("字段 '%s' 是其他类型，值为: %v\n", k, v)
            }
        }
    }

    // 再次编码回JSON字符串
    result, err := json.Marshal(data)
    if err != nil {
        log.Fatalf("编码失败: %v", err)
    }

    // 打印再次编码后的JSON，数字字段将保持原始格式
    fmt.Printf("再次编码后的JSON: %s\n", result)
}

解码后的数据类型: map[string]interface {}{"Name":"Fernando", "large_id":"9223372036854775807", "id":"12423434", "pi":"3.1415926535"}
字段 'Name' 是其他类型，值为: Fernando
字段 'large_id' 是 json.Number 类型，值为: 9223372036854775807
  -> 转换为 int64: 9223372036854775807
  -> 转换为 float64: 9223372036854775807.000000
字段 'id' 是 json.Number 类型，值为: 12423434
  -> 转换为 int64: 12423434
  -> 转换为 float64: 12423434.000000
字段 'pi' 是 json.Number 类型，值为: 3.1415926535
  -> 转换为 float64: 3.141593
再次编码后的JSON: {"Name":"Fernando","id":12423434,"large_id":9223372036854775807,"pi":3.1415926535}

package main

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

type User struct {
    ID      int64  `json:"id"`        // 使用 int64 精确存储大整数
    Name    string `json:"Name"`
    LargeID string `json:"large_id"`  // 或者直接使用 string 来存储，如果数字太大 int64 也无法容纳
}

func main() {
    jsonString := `{
        "id": 12423434,
        "Name": "Fernando",
        "large_id": 9223372036854775807
    }`

    var user User
    if err := json.Unmarshal([]byte(jsonString), &user); err != nil {
        log.Fatalf("解码失败: %v", err)
    }

    fmt.Printf("解码后的结构体: %+v\n", user)

    result, err := json.Marshal(user)
    if err != nil {
        log.Fatalf("编码失败: %v", err)
    }

    fmt.Printf("再次编码后的JSON: %s\n", result)
}