在Go语言中解析JSON时保留int64数值的策略

在go语言中，处理json数据是常见的操作。然而，当json中包含超出标准32位整数范围的大整数（例如64位整数）时，如果直接将其解析到`map[string]interface{}`这样的通用接口类型，go的`encoding/json`包默认会将这些数字视为浮点数（`float64`）进行处理。这通常会导致精度丢失，尤其是在需要精确表示大id、时间戳或其他长整型数据时。本教程将详细介绍如何在go中解析json时，有效保留原始的64位整数值。

1. 问题背景：interface{}的默认行为

当使用json.Unmarshal将JSON字符串解析到map[string]interface{}时，interface{}类型在遇到JSON数字时，会根据其值的大小和格式，将其解析为Go中的float64。对于形如4418489049307132905这样的64位整数，即使它是一个纯整数，也会被转换为float64，从而失去其精确性。

考虑以下JSON示例：

{"tags":[{"id":4418489049307132905},{"id":4418489049307132906}]}

如果尝试将其解析到map[string]interface{}，并尝试将id字段断言为int64，将会导致运行时错误，因为它实际上被解析成了float64。

2. 解决方案一：使用 json.Decoder 和 UseNumber()

encoding/json包提供了一个Decoder类型，它比Unmarshal函数提供了更细粒度的控制。通过Decoder的UseNumber()方法，我们可以指示解码器将所有JSON数字解析为json.Number类型，而不是默认的float64。json.Number本质上是一个字符串，它保留了数字的原始文本表示，从而避免了精度丢失。

立即学习“go语言免费学习笔记（深入）”；

2.1 json.Number 类型简介

json.Number定义如下：

type Number string

这意味着它是一个字符串类型，可以直接通过string(n)转换为字符串，然后再使用strconv包进行精确的数字转换。

2.2 实现步骤与代码示例

1. 创建json.Decoder实例，传入JSON数据的io.Reader。
2. 调用d.UseNumber()方法。
3. 使用d.Decode()进行解码。
4. 在访问数字字段时，将其断言为json.Number。
5. 使用strconv.ParseUint或strconv.ParseInt将json.Number转换为所需的uint64或int64。

package main

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

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

    // 使用map[string]interface{}作为目标，但通过Decoder控制解析行为
    dat := make(map[string]interface{})
    d := json.NewDecoder(bytes.NewBuffer(body))
    d.UseNumber() // 关键：指示解码器将数字解析为json.Number

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

    tags, ok := dat["tags"].([]interface{})
    if !ok {
        fmt.Println("tags is not an array")
        return
    }

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

        idNum, ok := tagMap["id"].(json.Number)
        if !ok {
            fmt.Printf("tag %d id is not a json.Number\n", i)
            continue
        }

        // 将json.Number转换为uint64
        idUint64, err := strconv.ParseUint(string(idNum), 10, 64)
        if err != nil {
            fmt.Printf("Error parsing id %s to uint64: %v\n", string(idNum), err)
            continue
        }
        fmt.Printf("Tag %d id: %d (Type: %T)\n", i, idUint64, idUint64)
    }
}

注意事项：

Find JSON Path Online

Easily find JSON paths within JSON objects using our intuitive Json Path Finder

30

查看详情

• 此方法适用于当JSON结构不完全固定，或者需要动态处理各种数据类型时。
• 需要手动将json.Number转换为具体的整数类型，增加了额外的转换步骤和错误处理。
• 如果数字可能为负数，应使用strconv.ParseInt。

3. 解决方案二：解码到自定义结构体

更Go惯用且通常更推荐的方法是定义一个与JSON结构精确匹配的Go结构体。通过这种方式，json.Unmarshal可以直接将JSON字段解析到结构体中指定类型的字段，从而避免了interface{}带来的类型推断问题。

3.1 定义结构体

为JSON数据定义一个或多个Go结构体，确保将64位整数对应的字段声明为uint64或int64类型。

package main

import (
    "encoding/json"
    "fmt"
)

// Tag 定义单个tag对象的结构
type Tag struct {
    ID uint64 `json:"id"` // 明确指定为uint64
}

// Data 定义整个JSON数据的结构
type Data struct {
    Tags []Tag `json:"tags"` // 包含Tag结构体切片
}

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

    var data Data // 声明目标结构体变量
    if err := json.Unmarshal(body, &data); err != nil {
        panic(err)
    }

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

3.2 优势与考量

• 类型安全和可读性： 结构体提供了强类型定义，使得代码更易于理解和维护。编译器可以在编译时捕获类型不匹配的错误。
• 简洁性： json.Unmarshal可以直接完成所有工作，无需额外的类型断言和字符串转换。
• 性能： 通常比使用interface{}和手动转换更高效。

注意事项：

• 要求JSON结构相对固定。如果JSON结构高度动态，可能需要结合其他方法（如自定义UnmarshalJSON方法）或回退到UseNumber()。
• 结构体字段名与JSON键名不一致时，需要使用json:"key_name"标签进行映射。

4. 跨语言兼容性考量：JavaScript中的64位整数

在处理包含64位整数的JSON时，如果你的应用程序也涉及JavaScript前端，需要特别注意。JavaScript的数字类型是IEEE 754双精度浮点数，它无法精确表示所有64位整数。JavaScript能够精确表示的最大整数是2^53 - 1（即9007199254740991）。超出此范围的整数在JavaScript中进行解析时，同样会面临精度丢失的问题。

建议：

• 如果64位整数需要精确地在JavaScript中使用，考虑将其在JSON中作为字符串传输。
• 在JavaScript端，接收到字符串后，可以使用第三方库（如BigInt，但兼容性需考虑）或自定义逻辑进行处理。

5. 总结

在Go语言中解析JSON并保留64位整数的精度，主要有两种推荐策略：

1. 对于动态或未知JSON结构，使用json.Decoder配合UseNumber()。 这将数字解析为json.Number（字符串），然后通过strconv.ParseUint或strconv.ParseInt进行精确转换。这种方法提供了最大的灵活性，但需要更多的手动类型处理。
2. 对于结构明确的JSON数据，定义并使用自定义Go结构体。 将结构体字段类型明确声明为uint64或int64，让json.Unmarshal直接进行类型匹配。这种方法更具Go语言的惯用风格，提供了更好的类型安全和代码可读性。

在选择哪种方法时，应根据JSON数据的动态性、代码的可维护性需求以及性能考量进行权衡。同时，切勿忽视JSON数据在其他平台（尤其是JavaScript）上的兼容性问题。

以上就是在Go语言中解析JSON时保留int64数值的策略的详细内容，更多请关注php中文网其它相关文章！