Wie kann ich Datentypen beim Parsen von JSON in Go beibehalten?

Erhaltung von Datentypen beim JSON-Parsing

Eine Herausforderung beim Parsen von JSON-Daten in Golang ist die automatische Konvertierung numerischer Werte in Gleitkommazahlen. Dies kann zu Inkonsistenzen mit den Originaldaten führen, insbesondere beim Umgang mit ganzzahligen Werten.

Um dieses Problem zu beheben, gibt es mehrere Techniken, um Datentypen während der JSON-Analyse beizubehalten.

Benutzerdefiniert JSON-Werte

Ein Ansatz besteht darin, den von Go bereitgestellten benutzerdefinierten JSON-Wertmechanismus zu verwenden. Dazu gehört die Erstellung eines benutzerdefinierten Typs, der die Schnittstellen json.Marshaler und json.Unmarshaler implementiert. Durch Überschreiben der Methoden MarshalJSON und UnmarshalJSON können Sie steuern, wie numerische Werte während der Serialisierung und Deserialisierung behandelt werden.

Go json.Number

Eine weitere Option ist die Verwendung von JSON .Number-Typ eingeführt in Go 1.8. Standardmäßig werden numerische Werte in JSON als float64 analysiert. Durch die Verwendung von json.Number und den Aufruf der Methoden Int64 oder Float64 können Sie die Zahl jedoch explizit in einen Ganzzahl- bzw. Gleitkommawert konvertieren.

Beispielimplementierung

package main

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

type MyJSONNumber struct {
    json.Number
}

func (mn *MyJSONNumber) MarshalJSON() ([]byte, error) {
    if n, err := strconv.Atoi(string(mn.Number)); err == nil {
        return []byte(strconv.Itoa(n)), nil
    }
    return []byte(mn.Number), nil
}

func (mn *MyJSONNumber) UnmarshalJSON(b []byte) error {
    if n, err := strconv.Atoi(string(b)); err == nil {
        mn.Number = strconv.Itoa(n)
        return nil
    }
    mn.Number = string(b)
    return nil
}

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)
        jnum := MyJSONNumber{json.Number(s)}
        n, err := jnum.Int64()
        if err == nil {
            parsed[key] = n
            continue
        }
        f, err := jnum.Float64()
        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

Das obige ist der detaillierte Inhalt vonWie kann ich Datentypen beim Parsen von JSON in Go beibehalten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!