Comment puis-je conserver les types de données entiers et flottants lors de l'analyse de JSON dans Go ?

Préservation des types de données dans l'analyse JSON : entiers sous forme d'entiers, flottants sous forme de flottants

Dans Golang, analyse des enregistrements JSON qui contiennent un mélange d'entiers et les valeurs flottantes nécessitent une manipulation minutieuse pour conserver les types de données d'origine. Cependant, l'implémentation actuelle utilisant le package encoding/json analyse tous les nombres comme des nombres flottants, ce qui peut entraîner des conflits de types dans le stockage des données.

Pour résoudre ce problème, nous pouvons utiliser plusieurs approches :

1. Gestion des valeurs JSON personnalisées :

Nous pouvons exploiter le mécanisme Go pour les valeurs JSON personnalisées afin d'identifier et de gérer les entiers et les flottants de manière appropriée.

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 Type :

Go fournit le type json.Number spécialement conçu pour gérer les numéros JSON. Cela nous permet d'analyser les nombres sous forme de flottants, puis d'extraire des entiers ou des flottants selon les besoins.

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

Ces approches offrent des moyens flexibles d'analyser et de conserver les valeurs entières et flottantes dans JSON, garantissant ainsi une représentation correcte des données lors du traitement ultérieur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!