Comment désorganiser une chaîne JSON auto-référentielle en Go avec un type dynamique ?

Désorganisation d'une chaîne JSON en une structure avec un élément auto-référentiel

Dans Go, désorganisation d'une chaîne JSON en une structure avec un élément auto-référentiel l’élément référentiel peut être un défi. Explorons un exemple spécifique et une solution pour résoudre ce problème efficacement.

Entrée JSON et définition de la structure

Considérez l'entrée JSON suivante :

[{
    "db": {
        "url": "mongodb://localhost",
        "port": "27000",
        "uname": "",
        "pass": "",
        "authdb": "",
        "replicas": [
            {
                "rs01": {
                    "url":"mongodb://localhost",
                    "port": "27001",
                    "uname": "",
                    "pass": "",
                    "authdb": ""
                }
            },
            {
                "rs02": {
                    "url":"mongodb://localhost",
                    "port": "27002",
                    "uname": "",
                    "pass": "",
                    "authdb": ""
                }
            }
        ]
    }
}]

Et la structure Go correspondante :

type DBS struct {
    URL      string   `json:"url"`
    Port     string   `json:"port"`
    Uname    string   `json:"uname"`
    Pass     string   `json:"pass"`
    Authdb   string   `json:"authdb"`
    Replicas []DBS     `json:"replicas"`
}

Fonction Unmarshal et Sortie

La fonction fournie, loadConfigs(), tente de désorganiser la chaîne JSON dans une tranche de structures DBS :

func loadConfigs() []DBS {
    var config []DBS
    raw, err := ioutil.ReadFile("./config.json")
    if err != nil {
        fmt.Println(err.Error())
        os.Exit(1)
    }

    json.Unmarshal(raw, &config)
    return config
}

Cependant, cela donne une tranche vide, [ ]DBS{, car l'entrée JSON n'est pas une tranche de structures DBS mais un wrapper d'objet JSON contenant un tableau de objets.

Solution : Mappage vers un type dynamique

Pour décrire complètement l'entrée JSON, un type dynamique comme une carte est requis. La définition de type mise à jour devient :

type DBSReplicated struct {
    DB *DBS `json:"db"`
}

type DBS struct {
    URL      string            `json:"url"`
    Port     string            `json:"port"`
    Uname    string            `json:"uname"`
    Pass     string            `json:"pass"`
    Authdb   string            `json:"authdb"`
    Replicas []map[string]*DBS `json:"replicas"`
}

En utilisant ce nouveau type, nous pouvons analyser l'entrée JSON avec précision :

var dbs []*DBReplicated
if err := json.Unmarshal([]byte(src), &dbs); err != nil {
    panic(err)
}

db := dbs[0].DB
fmt.Printf("%+v\n", db)
for _, dbs := range db.Replicas {
    for name, replica := range dbs {
        fmt.Printf("%s: %+v\n", name, replica)
    }
}

Sortie

&{URL:mongodb://localhost Port:27000 Uname: Pass: Authdb: Replicas:[map[rs01:0x10538200] map[rs02:0x10538240]]}
rs01: &{URL:mongodb://localhost Port:27001 Uname: Pass: Authdb: Replicas:[]}
rs02: &{URL:mongodb://localhost Port:27002 Uname: Pass: Authdb: Replicas:[]}

Clé Points

• Utilisez un type de carte pour modéliser une entrée JSON dynamique.
• Faites attention à la syntaxe appropriée pour les noms de propriétés de balises JSON.
• Envisagez d'utiliser des pointeurs dans la structure pour autoriser les structures imbriquées.

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!