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

  • Z时代
  • 2024-01-10
  • 分类：问答

首先让我解释一下这个问题。

我的Golang应用程序中包含了JSON记录流。它基本上将这些转发到数据存储（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

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

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

我需要一种以Ruby JSON解析器的方式将int解析为int并以float形式浮动的方法。

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

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

我尝试了这里概述的方法：验证int和float64的reflect.Type的其他方法（使用reflect），但是它不能准确地标识int：

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

回答：

例如，使用通用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建议的工作版本。

以上是 需要将JSON中的整数解析为整数，而不是浮点数 的全部内容， 来源链接： utcz.com/qa/401407.html

回到顶部