Comment aplatir efficacement les structures JSON imbriquées dans un format à un seul niveau dans Go ?

Démêler le JSON imbriqué : un guide simple pour l'aplatir

Le déchiffrement des structures JSON imbriquées peut être une tâche ardue. Dans cet article, nous explorons le domaine de l'aplatissement de ces hiérarchies de données complexes dans un format gérable à un seul niveau.

Pour illustrer le problème, considérons le code suivant dans Go :

<code class="go">type Social struct {
    GooglePlusPlusOnes  uint32 `json:"GooglePlusOne"`
    TwitterTweets       uint32 `json:"Twitter"`
    LinkedinShares      uint32 `json:"LinkedIn"`
    PinterestPins       uint32 `json:"Pinterest"`
    StumbleuponStumbles uint32 `json:"StumbleUpon"`
    DeliciousBookmarks  uint32 `json:"Delicious"`
    Facebook            Facebook
}

type Facebook struct {
    FacebookLikes    uint32 `json:"like_count"`
    FacebookShares   uint32 `json:"share_count"`
    FacebookComments uint32 `json:"comment_count"`
    FacebookTotal    uint32 `json:"total_count"`
}</code>

Ce code définit deux structures, Social et Facebook, représentant les données JSON avec deux niveaux d'imbrication. Le défi réside dans l'aplatissement de cette structure à un seul niveau, où Social contient toutes les données sans le type Facebook imbriqué.

La puissance d'UnmarshalJSON

Pour réaliser cet aplatissement , la fonction UnmarshalJSON entre en jeu. En définissant une méthode UnmarshalJSON personnalisée pour le type Social, nous pouvons contrôler la manière dont ses champs sont remplis à partir du JSON entrant.

Voici comment implémenter cette méthode :

<code class="go">func (s *Social) UnmarshalJSON(data []byte) error {
    type Alias Social

    var v Alias
    if err := json.Unmarshal(data, &v); err != nil {
        return err
    }

    *s = Social(v)

    // Flatten the Facebook fields
    s.FacebookLikes = v.Facebook.FacebookLikes
    s.FacebookShares = v.Facebook.FacebookShares
    s.FacebookComments = v.Facebook.FacebookComments
    s.FacebookTotal = v.Facebook.FacebookTotal

    return nil
}</code>

La puissance de la carte

Dans les cas où vous traitez uniquement des cartes, la fonction Aplatir ci-dessous peut aplatir efficacement une structure de carte imbriquée :

<code class="go">func Flatten(m map[string]interface{}) map[string]interface{} {
    o := make(map[string]interface{})
    for k, v := range m {
            switch child := v.(type) {
            case map[string]interface{}:
                    nm := Flatten(child)
                    for nk, nv := range nm {
                            o[k+"."+nk] = nv
                    }
            default:
                    o[k] = v
            }
    }
    return o
}</code>

Cette fonction aplatit de manière récursive maps, remplaçant les maps imbriquées par des clés délimitées par des points.

Conclusion

L'aplatissement du JSON imbriqué est une tâche courante dans divers scénarios de programmation. En tirant parti de la puissance d'UnmarshalJSON et de la fonction Flatten, vous pouvez simplifier efficacement la gestion et le traitement des structures JSON complexes. Ces techniques vous permettent d'extraire et d'accéder aux données de manière plus simple et plus efficace.

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!