Heim  >  Artikel  >  Backend-Entwicklung  >  Wie kann ich ein YAML-Feld in Go dynamisch in einen endlichen Satz von Strukturen analysieren?

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

Barbara Streisand
Barbara StreisandOriginal
2024-10-30 23:11:30209Durchsuche

How to Dynamically Parse a YAML Field into a Finite Set of Structs in Go?

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!

Stellungnahme:
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn