Wie kann ich ein YAML-Feld in Go dynamisch in einen endlichen Satz von Strukturen analysieren?

YAML-Feld dynamisch in eine endliche Menge von Strukturen in Go analysieren

Einführung

Das Parsen von YAML in eine Struktur in Go kann unkompliziert sein. Wenn ein YAML-Feld jedoch mehrere mögliche Strukturen darstellen kann, wird die Aufgabe komplexer. In diesem Artikel wird ein dynamischer Ansatz unter Verwendung des YAML-Pakets von Go untersucht.

Dynamisches Unmarshaling mit YAML v2

Für Yaml v2 kann der folgende Ansatz verwendet werden:

<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>

Dynamisches Unmarshaling mit YAML v3

Für Yaml v3 ist der Ansatz etwas anders:

<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>

Fazit

Diese dynamischen Unmarshaling-Techniken ermöglichen ein flexibles Parsen von YAML-Felder in einen endlichen Satz von Strukturen umwandeln, was eine elegantere und effizientere Lösung als die vorgeschlagene Problemumgehung darstellt. Erkunden Sie gerne die bereitgestellten Codeausschnitte und optimieren Sie den Ansatz basierend auf Ihren spezifischen Anforderungen.

Das obige ist der detaillierte Inhalt vonWie kann ich ein YAML-Feld in Go dynamisch in einen endlichen Satz von Strukturen analysieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!