Comment analyser dynamiquement un champ YAML en structures spécifiques dans Go ?

Analyse dynamique d'un champ YAML en structures spécifiques dans Go

Les fichiers YAML contiennent souvent des champs qui peuvent être représentés par plusieurs types de structures. Pour simplifier le code et les fichiers YAML, considérez les exemples YAML suivants :

kind: "foo"
spec:
  fooVal: 4

kind: "bar"
spec:
  barVal: 5

Les structures correspondantes pour l'analyse sont :

<code class="go">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"`
}</code>

En utilisant une interface map[string]{ } pour le champ Spec est une option, cela peut devenir complexe pour les fichiers YAML plus volumineux.

Solution élégante utilisant un Unmarshaler personnalisé

Une approche alternative consiste à créer un Unmarshaler personnalisé pour le type de spécification. Pour une utilisation avec yaml.v2, implémentez ce qui suit :

<code class="go">type yamlNode struct {
    unmarshal func(interface{}) error
}

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

type Spec struct {
    Kind string      `yaml:"kind"`
    Spec interface{} `yaml:"-"`
}</code>

<code class="go">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)
}</code>

Pour yaml.v3, utilisez ce qui suit :

<code class="go">type Spec struct {
    Kind string      `yaml:"kind"`
    Spec interface{} `yaml:"-"`
}</code>

<code class="go">func (s *Spec) UnmarshalYAML(n *yaml.Node) error {
    type S Spec
    type T struct {
        *S   `yaml:",inline"`
        Spec yaml.Node `yaml:"spec"`
    }

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

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

Cette solution mappe dynamiquement le YAML. champ à la structure appropriée en fonction du champ "kind", éliminant ainsi le besoin d'étapes supplémentaires ou de consommation de mémoire.

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!