Golang中如何保持map[string]interface{}的int64值

在Go中，当使用json.Unmarshal或json.Decode到map[string]interface{}时，JSON中的数字默认会被解析为float64类型。由于浮点数的精度限制，大整数可能会丢失精度。

解决方案：使用json.Decoder的UseNumber()方法

package main

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

func main() {
	jsonStr := `{
		"data": {
			"list": [
				{
					"advertiser_id": 6868310788839309317,
					"advertiser_name": "fggddf"
				}
			]
		}
	}`

	// 方法1：使用UseNumber()
	genericBody := map[string]interface{}{}
	dec := json.NewDecoder(strings.NewReader(jsonStr))
	dec.UseNumber() // 关键：使用Number类型而不是float64
	err := dec.Decode(&genericBody)
	if err != nil {
		panic(err)
	}

	// 提取并转换数字
	data := genericBody["data"].(map[string]interface{})
	list := data["list"].([]interface{})
	item := list[0].(map[string]interface{})
	
	// 将json.Number转换为int64
	idStr := item["advertiser_id"].(json.Number)
	idInt64, err := idStr.Int64()
	if err != nil {
		panic(err)
	}
	
	fmt.Printf("原始值: %v\n", idStr)
	fmt.Printf("int64值: %d\n", idInt64)
	fmt.Printf("完整精度: %d\n", idInt64)
}

处理嵌套结构的通用方法

func decodeWithFullPrecision(body io.Reader) (map[string]interface{}, error) {
	genericBody := map[string]interface{}{}
	dec := json.NewDecoder(body)
	dec.UseNumber()
	err := dec.Decode(&genericBody)
	if err != nil {
		return nil, err
	}
	
	// 递归处理所有数字
	processNumbers(genericBody)
	return genericBody, nil
}

func processNumbers(data interface{}) {
	switch v := data.(type) {
	case map[string]interface{}:
		for key, val := range v {
			switch val := val.(type) {
			case json.Number:
				// 尝试转换为int64，如果失败则保持为string
				if intVal, err := val.Int64(); err == nil {
					v[key] = intVal
				} else if floatVal, err := val.Float64(); err == nil {
					v[key] = floatVal
				}
			default:
				processNumbers(val)
			}
		}
	case []interface{}:
		for i, item := range v {
			processNumbers(item)
		}
	}
}

使用自定义类型保持灵活性

type FlexibleMap map[string]interface{}

func (fm *FlexibleMap) UnmarshalJSON(data []byte) error {
	var temp map[string]interface{}
	dec := json.NewDecoder(bytes.NewReader(data))
	dec.UseNumber()
	if err := dec.Decode(&temp); err != nil {
		return err
	}
	
	// 转换所有json.Number为合适的类型
	convertNumbers(temp)
	*fm = temp
	return nil
}

func convertNumbers(m map[string]interface{}) {
	for k, v := range m {
		switch val := v.(type) {
		case json.Number:
			// 尝试int64，然后float64，最后保持string
			if i, err := val.Int64(); err == nil {
				m[k] = i
			} else if f, err := val.Float64(); err == nil {
				m[k] = f
			} else {
				m[k] = val.String()
			}
		case map[string]interface{}:
			convertNumbers(val)
		case []interface{}:
			for i, item := range val {
				if subMap, ok := item.(map[string]interface{}); ok {
					convertNumbers(subMap)
				}
			}
		}
	}
}

在你的代码中直接应用

genericBody := map[string]interface{}{}
dec := json.NewDecoder(genericResp.Body)
dec.UseNumber() // 添加这一行
err = dec.Decode(&genericBody)

// 现在可以安全地提取大整数
data := genericBody["data"].(map[string]interface{})
list := data["list"].([]interface{})
for _, item := range list {
	advertiser := item.(map[string]interface{})
	if id, ok := advertiser["advertiser_id"].(json.Number); ok {
		fullInt64, _ := id.Int64()
		fmt.Printf("完整int64值: %d\n", fullInt64)
	}
}

使用dec.UseNumber()后，JSON中的数字会被解析为json.Number类型（本质上是string），然后可以通过Int64()、Float64()或String()方法按需转换，从而保持完整的精度。