Les champs YAML en analyse dynamique vers un ensemble fini de structures dans Go

analyser les fichiers yaml est une tâche commune dans de nombreuses applications. Cependant, parfois un fichier YAML peut contenir des champs qui doivent être représentés par différents types de structures. Cela peut conduire à un code complexe et à des fichiers YAML encombrés.

Par exemple, considérez les fichiers yaml suivants:

kind: "foo"
spec:
  fooVal: 4

kind: "bar"
spec:
  barVal: 5

et les structures correspondantes pour l'analyse:

type Spec struct {
    Kind string      `yaml:"kind"`
    Spec interface{} `yaml:"spec"`
}

type Foo struct {
    FooVal int `yaml:"fooVal"`
}

type Bar struct {
    BarVal int `yaml:"barVal"`
}

Une approche consiste à utiliser une interface map [String] {} comme type pour le champ de spécification. Cependant, cette approche peut conduire à une complexité et à une consommation de mémoire supplémentaires, en particulier pour les grands fichiers YAML.

Une solution plus élégante consiste à utiliser la structure yamlnode:

type yamlNode struct {
    unmarshal func(interface{}) error
}

func (n *yamlNode) UnmarshalYAML(unmarshal func(interface{}) error) error {
    n.unmarshal = unmarshal
    return nil
}

et modifiez la structure de la spécification pour l'utiliser:

type Spec struct {
    Kind string      `yaml:"kind"`
    Spec interface{} `yaml:"-" json:"-"`
}

Avec ces modifications, la fonction unmarshalyaml pour les spécifications peut analyser dynamiquement et unmarshal le champ de spécification en un type de structure spécifique:

func (s *Spec) UnmarshalYAML(unmarshal func(interface{}) error) error {
    type S Spec
    type T struct {
        S    `yaml:",inline"`
        Spec yamlNode `yaml:"spec"`
    }

    obj := &T{}
    if err := unmarshal(obj); err != nil {
        return err
    }
    *s = Spec(obj.S)

    switch s.Kind {
    case "foo":
        s.Spec = new(Foo)
    case "bar":
        s.Spec = new(Bar)
    default:
        panic("kind unknown")
    }
    return obj.Spec.unmarshal(s.Spec)
}

Cette approche fournit une solution plus élégante et efficace pour analyser dynamiquement les champs YAML dans un ensemble fini de structures, ce qui rend votre code et vos fichiers YAML beaucoup plus propres et plus faciles à gérer.