1.问题现象描述

使用 json.Unmarshal()，反序列化时，出现了科学计数法，参考代码如下：

  1. jsonStr := `{"number":1234567}`
  2. result := make(map[string]interface{})
  3. err := json.Unmarshal([]byte(jsonStr), &result)
  4. if err != nil {
  5.     fmt.Println(err)
  6. }
  7. fmt.Println(result)
  9. // 输出
  10. // map[number:1.234567e+06]

这个问题不是必现，只有当数字的位数大于 6 位时，才会变成了科学计数法。

2.问题影响描述

当数据结构未知，使用 map[string]interface{} 来接收反序列化结果时，如果数字的位数大于 6 位，都会变成科学计数法，用到的地方都会受到影响。

3.引起问题的原因

从 encoding/json 可以找到答案，看一下这段注释：

  1. // To unmarshal JSON into an interface value,
  2. // Unmarshal stores one of these in the interface value:
  3. //
  4. //    bool, for JSON booleans
  5. //    float64, for JSON numbers
  6. //    string, for JSON strings
  7. //    []interface{}, for JSON arrays
  8. //    map[string]interface{}, for JSON objects
  9. //    nil for JSON null

是因为当 JSON 中存在一个比较大的数字时，它会被解析成 float64 类型，就有可能会出现科学计数法的形式。

4.问题的解决方案

方案一

强制类型转换，参考代码如下：

  1. jsonStr := `{"number":1234567}`
  2. result := make(map[string]interface{})
  3. err := json.Unmarshal([]byte(jsonStr), &result)
  4. if err != nil {
  5.     fmt.Println(err)
  6. }
  7. fmt.Println(int(result["number"].(float64)))
  9. // 输出
  10. // 1234567

方案二

尽量避免使用 interface，对 json 字符串结构定义结构体，快捷方法可使用在线工具：https://mholt.github.io/json-to-go/。

  1. type Num struct {
  2.     Number int `json:"number"`
  3. }
  5. jsonStr := `{"number":1234567}`
  6. var result Num
  7. err := json.Unmarshal([]byte(jsonStr), &result)
  8. if err != nil {
  9.     fmt.Println(err)
  10. }
  11. fmt.Println(result)
  13. // 输出
  14. // {1234567}

方案三

使用 UseNumber() 方法。

  1. jsonStr := `{"number":1234567}`
  2. result := make(map[string]interface{})
  3. d := json.NewDecoder(bytes.NewReader([]byte(jsonStr)))
  4. d.UseNumber()
  5. err := d.Decode(&result)
  6. if err != nil {
  7.     fmt.Println(err)
  8. }
  9. fmt.Println(result)
  11. // 输出
  12. // map[number:1234567]

这时一定要注意 result["number"] 的数据类型！

  1. fmt.Println(fmt.Sprintf("type: %v", reflect.TypeOf(result["number"])))
  3. // 输出
  4. // type: json.Number

通过代码可以看出 json.Number 其实就是字符串类型：

  1. // A Number represents a JSON number literal.
  2. type Number string

如果转换其他类型，参考如下代码：

  1. // 转成 int64
  2. numInt, _ := result["number"].(json.Number).Int64()
  3. fmt.Println(fmt.Sprintf("value: %v, type: %v", numInt, reflect.TypeOf(numInt)))
  5. // 输出
  6. // value: 1234567, type: int64
  8. // 转成 string
  9. numStr := result["number"].(json.Number).String()
  10. fmt.Println(fmt.Sprintf("value: %v, type: %v", numStr, reflect.TypeOf(numStr)))
  12. // 输出
  13. // value: 1234567, type: string