Question

首先让我解释一下问题。

我有一个JSON记录流进入我的Golang应用程序。它基本上将这些转发到数据存储（InfluxDB）。 JSON中有一些整数值，还有一些浮点值。必须将它们与原始数据类型一起转发到数据存储。否则，将发生类型冲突，并且写操作将失败。

Ruby JSON解析器可以轻松做到这一点：

require 'json'
obj = { "a" => 123, "b" => 12.3 }
parsed = JSON.parse(obj.to_json)

print parsed["a"].class # => Integer
print parsed["b"].class # => Float

Golang中的encoding/json软件包确实有一些麻烦（所有数字都解析为浮点数）：

package main

import "encoding/json"
import "fmt"

func main () {
  str := "{\"a\":123,\"b\":12.3}"
  var parsed map[string]interface{}
  json.Unmarshal([]byte(str), &parsed)
  for key, val := range parsed {
    switch val.(type) {
    case int:
      fmt.Println("int type: ", key)
    case float64:
      fmt.Println("float type: ", key)
    default:
      fmt.Println("unknown type: ", key)
    }
  }
}

哪些印刷品：

float type:  a
float type:  b

我需要一种将int解析为int的方法，并像Ruby JSON解析器一样将float转换为float。

在这种情况下，将所有内容解析为字符串并检查是否有小数位是不可行的。某些值以字符串形式出现，例如“ 123”，我需要将这些推送为字符串。

我没有解析对象的结构，也不是一个选项。 golang应用程序实际上并不关心模式，而只是在接收到输入时转发该输入。

我尝试了此处概述的方法：Other ways of verifying reflect.Type for int and float64（使用reflect），但无法准确识别int：

t := reflect.TypeOf(parsed["a"])
k := t.Kind()
k == reflect.Int // false
k == reflect.Float64 // true

Answer 1

例如，使用通用Go机制自定义JSON值的Ruby JSON数字类型，

package main

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

func main() {
    str := `{"a":123,"b":12.3,"c":"123","d":"12.3","e":true}`
    var raw map[string]json.RawMessage
    err := json.Unmarshal([]byte(str), &raw)
    if err != nil {
        panic(err)
    }
    parsed := make(map[string]interface{}, len(raw))
    for key, val := range raw {
        s := string(val)
        i, err := strconv.ParseInt(s, 10, 64)
        if err == nil {
            parsed[key] = i
            continue
        }
        f, err := strconv.ParseFloat(s, 64)
        if err == nil {
            parsed[key] = f
            continue
        }
        var v interface{}
        err = json.Unmarshal(val, &v)
        if err == nil {
            parsed[key] = v
            continue
        }
        parsed[key] = val
    }
    for key, val := range parsed {
        fmt.Printf("%T: %v %v\n", val, key, val)
    }
}

游乐场：https://play.golang.org/p/VmG8IZV4CG_Y

输出：

int64: a 123 
float64: b 12.3 
string: c 123 
string: d 12.3 
bool: e true

另一个示例，使用Go json.Number类型的Ruby JSON数字类型，

package main

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

func main() {
    str := `{"a":123,"b":12.3,"c":"123","d":"12.3","e":true}`
    var parsed map[string]interface{}
    d := json.NewDecoder(strings.NewReader(str))
    d.UseNumber()
    err := d.Decode(&parsed)
    if err != nil {
        panic(err)
    }
    for key, val := range parsed {
        n, ok := val.(json.Number)
        if !ok {
            continue
        }
        if i, err := n.Int64(); err == nil {
            parsed[key] = i
            continue
        }
        if f, err := n.Float64(); err == nil {
            parsed[key] = f
            continue
        }
    }
    for key, val := range parsed {
        fmt.Printf("%T: %v %v\n", val, key, val)
    }
}

游乐场：https://play.golang.org/p/Hk_Wb0EM-aY

输出：

int64: a 123
float64: b 12.3
string: c 123
string: d 12.3
bool: e true

@ShudiptaSharma的建议的工作版本。

Answer 2

json包中存在类型json.Number，它具有3种格式函数String() string，Float64() (float64, error)和Int64() (int64, error)。我们可以使用它们来解析整数和浮点类型。

因此，我以这种方式处理json整数解析：

package main

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

func main () {
    str := "{\"a\":123,\"b\":12.3}"

    var parsed map[string]interface{}
    d := json.NewDecoder(strings.NewReader(str))
    d.UseNumber()
    fmt.Println(d.Decode(&parsed))

    for key, val := range parsed {
        fmt.Println(reflect.TypeOf(val))
        fmt.Printf("decoded to %#v\n", val)
        switch val.(type) {
        case json.Number:
            if n, err := val.(json.Number).Int64(); err == nil {
                fmt.Println("int64 type: ", key, n)
            } else if f, err := val.(json.Number).Float64(); err == nil {
                fmt.Println("float64 type: ", key, f)
            } else {
                fmt.Println("string type: ", key, val)
            }
        default:
            fmt.Println("unknown type: ", key, val)
        }
        fmt.Println("===============")
    }
}

需要将JSON中的整数解析为整数，而不是浮点数

2 个答案: