Wie kann ich Integer- und Float-Datentypen beim Parsen von JSON in Go beibehalten?

Beibehalten von Datentypen beim JSON-Parsing: Ganzzahlen als Ganzzahlen, Gleitkommazahlen als Gleitkommazahlen

In Golang Parsen von JSON-Datensätzen, die eine Mischung aus Ganzzahlen enthalten und Float-Werte erfordern eine sorgfältige Handhabung, um die ursprünglichen Datentypen beizubehalten. Allerdings analysiert die aktuelle Implementierung, die das Paket „encoding/json“ verwendet, alle Zahlen als Gleitkommazahlen, was möglicherweise zu Typkonflikten in der Datenspeicherung führt.

Um dieses Problem zu lösen, können wir mehrere Ansätze anwenden:

1. Benutzerdefinierte JSON-Wertbehandlung:

Wir können den Go-Mechanismus für benutzerdefinierte JSON-Werte nutzen, um Ganzzahlen und Gleitkommazahlen entsprechend zu identifizieren und zu verarbeiten.

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

2. json.Number-Typ:

Go stellt den json.Number-Typ bereit, der speziell für die Verarbeitung von JSON-Nummern entwickelt wurde. Dies ermöglicht uns, Zahlen als Gleitkommazahlen zu analysieren und dann nach Bedarf Ganzzahlen oder Gleitkommazahlen zu extrahieren.

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

Diese Ansätze bieten flexible Möglichkeiten, Ganzzahl- und Gleitkommawerte in JSON zu analysieren und zu bewahren und so eine korrekte Datendarstellung bei der nachfolgenden Verarbeitung sicherzustellen.

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