Go踩过的坑之JSON 序列化 int64 精度丢失

package main

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

type User struct {
    ID   int64  `json:"id"`
    Name string `json:"name"`
}

func main() {
    // 模拟一个大的int64数值
    user := User{
        ID:   9223372036854775807, // 这是一个很大的整数
        Name: "张三",
    }
    
    // 序列化为JSON
    data, err := json.Marshal(user)
    if err != nil {
        log.Fatal(err)
    }
    
    fmt.Printf("序列化结果: %s\n", string(data))
    
    // 现在模拟前端JavaScript环境解析（使用interface{}）
    var temp map[string]interface{}
    if err := json.Unmarshal(data, &temp); err != nil {
        log.Fatal(err)
    }
    
    // 再次序列化查看结果
    data2, _ := json.Marshal(temp)
    fmt.Printf("经过interface{}处理后的结果: %s\n", string(data2))
}

package main

import (
    "encoding/json"
    "fmt"
)

type UserString struct {
    ID   int64  `json:"id,string"`  // 关键：添加,string标签
    Name string `json:"name"`
}

func stringSolution() {
    user := UserString{
        ID:   9223372036854775807,
        Name: "李四",
    }
    
    data, _ := json.Marshal(user)
    fmt.Printf("字符串序列化: %s\n", string(data))
    // 输出: {"id":"9223372036854775807","name":"李四"}
    
    // 反序列化同样有效
    var newUser UserString
    json.Unmarshal(data, &newUser)
    fmt.Printf("反序列化后ID: %d\n", newUserID)
}

package main

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

func useNumberSolution() {
    jsonStr := `{"id": 9223372036854775807, "name": "王五"}`
    
    // 传统方式（会出问题）
    var data1 map[string]interface{}
    json.Unmarshal([]byte(jsonStr), &data1)
    fmt.Printf("传统方式: %v\n", data1["id"])
    
    // 使用UseNumber的方式
    var data2 map[string]interface{}
    decoder := json.NewDecoder(strings.NewReader(jsonStr))
    decoder.UseNumber()  // 启用UseNumber
    decoder.Decode(&data2)
    
    if id, ok := data2["id"].(json.Number); ok {
        // 可以按需转换为int64或float64
        intID, _ := id.Int64()
        fmt.Printf("UseNumber方式: %d\n", intID)
    }
}

package main

import (
    "encoding/json"
    "strconv"
)

// 自定义int64类型，序列化为字符串
type Int64String int64

func (i Int64String) MarshalJSON() ([]byte, error) {
    return []byte(strconv.FormatInt(int64(i), 10)), nil
}

func (i *Int64String) UnmarshalJSON(data []byte) error {
    // 去除字符串的引号
    s := string(data)
    if len(s) > 0 && s[0] == '"' {
        s = s[1 : len(s)-1]
    }
    
    val, err := strconv.ParseInt(s, 10, 64)
    if err != nil {
        return err
    }
    *i = Int64String(val)
    return nil
}

type UserCustom struct {
    ID   Int64String `json:"id"`  // 使用自定义类型
    Name string      `json:"name"`
}

func customTypeSolution() {
    user := UserCustom{
        ID:   Int64String(9223372036854775807),
        Name: "赵六",
    }
    
    data, _ := json.Marshal(user)
    fmt.Printf("自定义类型序列化: %s\n", string(data))
}

package main

import (
    "fmt"
    jsoniter "github.com/json-iterator/go"
    "github.com/json-iterator/go/extra"
)

func jsoniterSolution() {
    // 启用模糊解码器
    extra.RegisterFuzzyDecoders()
    
    var json = jsoniter.ConfigCompatibleWithStandardLibrary
    
    type Data struct {
        ID int64 `json:"id"`
    }
    
    // 即使JSON中数字是字符串形式，也能正确解析
    jsonStr := `{"id": "9223372036854775807"}`
    
    var data Data
    json.UnmarshalFromString(jsonStr, &data)
    fmt.Printf("jsoniter解析结果: %d\n", data.ID)
}