Wie kann ich Ganzzahlen und Gleitkommazahlen aus JSON in Golang genau analysieren?

Ganzzahlen als Ganzzahlen und Gleitkommazahlen als Gleitkommazahlen in JSON mit Golang analysieren

In einer Golang-Anwendung, die einen Strom von JSON-Datensätzen zur Weiterleitung empfängt Bei einem Datenspeicher (InfluxDB) ist es wichtig, den ursprünglichen Datentyp der Ganzzahl- und Gleitkommawerte beizubehalten, um Typkonflikte zu vermeiden und ein erfolgreiches Schreiben sicherzustellen Operationen. Während der Ruby-JSON-Parser diese Aufgabe mühelos ausführt, analysiert das Paket „encoding/json“ in Golang zunächst alle Zahlen als Gleitkommazahlen, was möglicherweise zu Typkonflikten und Schreibfehlern führt.

Eine Problemumgehung mit benutzerdefinierten JSON-Werten

Um das Verhalten des Ruby-JSON-Parsers zu reproduzieren, besteht ein Ansatz darin, den generischen Go-Mechanismus für benutzerdefinierte JSON-Werte zu verwenden. Bei dieser Methode werden JSON-Zahlen als Byte-Arrays (json.RawMessage) dargestellt und mit strconv.ParseInt und strconv.ParseFloat analysiert. Dies ermöglicht eine genaue Konvertierung von Ganzzahlen und Gleitkommazahlen:

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)
    }
}

Ausgabe:

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

Verwendung des json.Number-Typs

Ein alternativer Ansatz besteht in der Verwendung des Go-Typs json.Number, der eine effiziente direkte Analyse von Ganzzahlen und Gleitkommazahlen ermöglicht aus den JSON-Daten:

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)
    }
}

Ausgabe:

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

Diese Methoden bieten effektive Lösungen für die Beibehaltung des ursprünglichen Datentyps von Ganzzahlen und Gleitkommazahlen während der JSON-Analyse Golang sorgt für eine genaue und zuverlässige Datenverarbeitung.

Das obige ist der detaillierte Inhalt vonWie kann ich Ganzzahlen und Gleitkommazahlen aus JSON in Golang genau analysieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!