Go JSON 解析：避免 int64 精度丢失的两种策略

聖光之護

发布时间：2025-10-15 09:19:24

1052人浏览过

来源于php中文网

原创

Go JSON 解析：避免 int64 精度丢失的两种策略

本文探讨在 go 语言中解析 json 时，如何有效避免大整数（如 `int64`）被默认转换为 `float64` 导致精度丢失的问题。我们将介绍两种核心策略：一是利用 `json.decoder` 的 `usenumber()` 方法将数字作为字符串处理，再手动转换；二是定义具有 `uint64` 或 `int64` 字段的 go 结构体进行直接解析，确保数据完整性。

Go JSON 解析中的 int64 精度丢失问题

在 Go 语言中处理 JSON 数据时，encoding/json 包的 json.Unmarshal 函数在默认情况下会将 JSON 中的数值类型（尤其是大整数）解析为 float64。这对于一般的浮点数或较小的整数可能不是问题，但当遇到超出 float64 精确表示范围的 64 位整数（如 int64 或 uint64）时，这种自动转换会导致精度丢失，从而获取到不正确的数据。

例如，当解析一个包含 4418489049307132905 这样大整数的 JSON 字符串时，如果直接将其映射到 map[string]interface{}，Go 会将其识别为 float64。尝试将其断言为 int64 将会失败，因为底层类型已不再是整数，并且 float64 自身也可能无法精确表示该大整数。

package main

import (
    "encoding/json"
    "fmt"
)

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

    var dat map[string]interface{}
    if err := json.Unmarshal(body, &dat); err != nil {
        panic(err)
    }

    tags := dat["tags"].([]interface{})
    // 尝试直接断言为 int64 会导致运行时错误，因为实际类型是 float64
    // fmt.Println("tag: ", 0, " id: ", tags[0].(map[string]interface{})["id"].(int64))

    // 实际输出会是 float64，且可能已发生精度丢失
    fmt.Printf("Parsed ID type: %T, value: %.0f\n", tags[0].(map[string]interface{})["id"], tags[0].(map[string]interface{})["id"])
    // 示例输出可能为：Parsed ID type: float64, value: 4418489049307132904
    // 注意：原始值是 4418489049307132905，这里已经发生了精度丢失。
}

为了解决这一问题，Go 提供了两种主要策略来确保 64 位整数在 JSON 解析过程中不丢失精度。

解决方案一：使用 json.Decoder 配合 UseNumber()

encoding/json 包中的 json.Decoder 提供了比 json.Unmarshal 更精细的控制。通过调用 Decoder 的 UseNumber() 方法，我们可以指示解码器将所有 JSON 数字解析为 json.Number 类型，而不是 float64。json.Number 本质上是一个字符串类型，它完整地保留了原始数字的文本表示，从而避免了任何精度丢失。之后，我们可以根据需要将 json.Number 转换为 int64 或 uint64。

实现步骤：

创建一个 json.Decoder 实例，从 bytes.Buffer 或其他 io.Reader 中读取 JSON 数据。
调用 d.UseNumber() 启用数字的 json.Number 解析模式。
使用 d.Decode() 将数据解码到 map[string]interface{} 或其他泛型结构中。
当访问数字字段时，将其断言为 json.Number 类型。
使用 strconv 包中的 ParseUint 或 ParseInt 函数将 json.Number 字符串转换为所需的整数类型。

示例代码：

package main

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

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

    dat := make(map[string]interface{})
    d := json.NewDecoder(bytes.NewBuffer(body))
    d.UseNumber() // 启用 UseNumber 模式

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

    tags := dat["tags"].([]interface{})
    firstTagID := tags[0].(map[string]interface{})["id"]

    // 断言为 json.Number 类型
    n, ok := firstTagID.(json.Number)
    if !ok {
        panic("ID is not a json.Number")
    }

    // 将 json.Number 转换为 uint64
    // 注意：根据实际数据范围和符号选择 ParseUint 或 ParseInt
    i64, err := strconv.ParseUint(string(n), 10, 64)
    if err != nil {
        panic(err)
    }
    fmt.Printf("Using UseNumber: Type: %T, Value: %d\n", i64, i64) // Output: Using UseNumber: Type: uint64, Value: 4418489049307132905

    secondTagID := tags[1].(map[string]interface{})["id"].(json.Number)
    i64_2, _ := strconv.ParseUint(string(secondTagID), 10, 64)
    fmt.Printf("Using UseNumber: Type: %T, Value: %d\n", i64_2, i64_2) // Output: Using UseNumber: Type: uint64, Value: 4418489049307132906
}

优点：

LOGO.com

在线生成Logo，100%免费

下载

提供了对数字解析的精确控制，完全避免了精度丢失。
适用于 JSON 结构不完全确定或需要泛型处理的场景。

缺点：

需要手动将 json.Number 转换为具体整数类型，增加了代码的复杂性。
对于深层嵌套的 JSON 结构，类型断言可能变得繁琐。

解决方案二：定义具体的 Go 结构体

当 JSON 数据的结构已知时，最推荐且最符合 Go 风格的解决方案是定义一个与 JSON 结构相匹配的 Go 结构体。通过将结构体字段的类型明确声明为 uint64 或 int64，json.Unmarshal 会自动尝试将 JSON 中的数字解析为这些指定的类型，从而避免默认的 float64 转换。

实现步骤：

根据 JSON 数据的结构，定义一个或多个 Go 结构体。
将需要保留 int64 或 uint64 精度的字段声明为 uint64 或 int64 类型。
使用 json.Unmarshal 直接将 JSON 字节流解码到结构体实例中。

示例代码：

package main

import (
    "encoding/json"
    "fmt"
)

// 定义与 JSON 结构对应的 Go 结构体
type Tag struct {
    ID uint64 `json:"id"` // 将 id 字段声明为 uint64，确保精度
}

type Data struct {
    Tags []Tag `json:"tags"`
}

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

    var data Data
    if err := json.Unmarshal(body, &data); err != nil {
        panic(err)
    }

    fmt.Printf("Using specific struct: Type: %T, Value: %d\n", data.Tags[0].ID, data.Tags[0].ID) // Output: Using specific struct: Type: uint64, Value: 4418489049307132905
    fmt.Printf("Using specific struct: Type: %T, Value: %d\n", data.Tags[1].ID, data.Tags[1].ID) // Output: Using specific struct: Type: uint64, Value: 4418489049307132906
}

优点：