Comment analyser des clés dynamiques dans YAML avec Go ?

Analyse dynamique des clés dans YAML avec Go

Lorsque vous travaillez avec des fichiers YAML dans Go, vous pouvez rencontrer des scénarios dans lesquels les noms de clés dans le fichier varient. Ceci est souvent utilisé à des fins de versionnage d'API ou de configuration dynamique. Pour analyser efficacement de telles structures YAML, vous devrez utiliser des stratégies d'analyse personnalisées.

Résumé du problème

Dans le contexte de la gestion des versions d'API, il est possible d'avoir un fichier YAML avec des clés représentant différentes versions , tels que "V1", "V2", "V3", etc. Le problème est que ces versions peuvent ne pas toujours être présentes dans le fichier et leur ordre peut être incohérent.

Approche Unmarshaler personnalisée

Pour résoudre ce problème, envisagez d'implémenter un Unmarshaler personnalisé pour le correspondant. structure des données. Cela vous permet de contrôler le processus de démarshalling et de gérer les valeurs de clé dynamiques.

<code class="go">package main

import (
    "fmt"

    "gopkg.in/yaml.v2"
)

type MajorVersion struct {
    Current                string   `yaml:"current"`
    MimeTypes              []string `yaml:"mime_types"`
    SkipVersionValidation  bool     `yaml:"skip-version-validation"`
    SkipMimeTypeValidation bool     `yaml:"skip-mime-type-validation"`
}

type Environment struct {
    SkipHeaderValidation bool
    Versions             map[string]MajorVersion
}

func (e *Environment) UnmarshalYAML(unmarshal func(interface{}) error) error {
    var params struct {
        SkipHeaderValidation bool `yaml:"skip-header-validation"`
    }
    if err := unmarshal(&amp;params); err != nil {
        return err
    }
    var versions map[string]MajorVersion
    if err := unmarshal(&amp;versions); err != nil {
        // Here we expect an error because a boolean cannot be converted to a MajorVersion
        if _, ok := err.(*yaml.TypeError); !ok {
            return err
        }
    }
    e.SkipHeaderValidation = params.SkipHeaderValidation
    e.Versions = versions
    return nil
}

func main() {
    var e map[string]Environment
    if err := yaml.Unmarshal([]byte(data), &amp;e); err != nil {
        fmt.Println(err.Error())
    }
    fmt.Printf("%#v\n", e)
}</code>

En définissant un Unmarshaler personnalisé pour la structure Environment, vous pouvez gérer efficacement les structures booléennes et imbriquées dans votre fichier YAML.

Conclusion

Les Unmarshaler personnalisés offrent un moyen puissant d'analyser les structures YAML complexes et dynamiques dans Golang. En mettant en œuvre une logique de démarshaling personnalisée, vous pouvez adapter vos structures de données à différents formats de clé, facilitant ainsi l'utilisation des fichiers YAML dans des situations où la structure peut changer au fil du temps.

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!