Comment analyser efficacement les structures JSON imbriquées avec des éléments auto-référencés dans Go ?

Démêler les structures JSON imbriquées avec des relations complexes

Lorsque vous travaillez avec des données JSON, vous pouvez rencontrer des situations où un élément d'une structure est lui-même un structurer. Démêler des structures aussi complexes nécessite une compréhension de l'analyse JSON et une modélisation efficace des données.

Le défi : analyser JSON avec un élément d'auto-référencement

Considérez la chaîne JSON suivante, où l'objet "db" contient des "répliques" imbriquées qui reflètent la "db" structure :

[{
    "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 une définition de structure 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`
}

Comprendre l'erreur : échec du démarshal

Tentative de démarshalage de la chaîne JSON dans une tranche de DBS à l'aide de la fonction json.Unmarshal entraînera un vide slice :

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
}

Cela se produit car les données JSON ne correspondent pas à la définition de la structure. Le wrapper externe du tableau JSON et l'objet "db" imbriqué dans les répliques ne sont pas explicitement représentés dans la structure.

Solution : Modélisation de structures JSON dynamiques

Pour représenter avec précision Pour la structure JSON, nous avons besoin d'un type dynamique pouvant s'adapter à différentes clés et valeurs. Une map[string]DBS peut modéliser ce comportement dynamique, où la clé représente le nom de la propriété et la valeur est une représentation DBS.

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"`
}

Affinage du modèle : utilisation de pointeurs

Pour simplifier la sortie et améliorer les performances, nous pouvons utiliser des pointeurs pour le type DBS dans la carte des répliques, comme indiqué ci-dessous :

type DBReplicated 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"`
}

Conclusion

En comprenant les complexités des structures JSON et en utilisant des techniques de modélisation de données appropriées, les développeurs peuvent analyser et travailler efficacement avec des données complexes dans Golang. Cela permet une manipulation efficace des données et une représentation précise des structures de données hiérarchiques.

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!