„Wenn ein Arbeiter seine Arbeit gut machen will, muss er zuerst seine Werkzeuge schärfen.“ – Konfuzius, „Die Gespräche des Konfuzius. Lu Linggong“
Titelseite > Programmierung > 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?

Veröffentlicht am 08.11.2024
Durchsuche:269

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:

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:"-"
}
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)
}

Dynamisches Unmarshaling mit YAML v3

Für Yaml v3 ist der Ansatz etwas anders:

type Spec struct {
    Kind string      `yaml:"kind"`
    Spec interface{} `yaml:"-"
}
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)
}

Fazit

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

Neuestes Tutorial Mehr>

Haftungsausschluss: Alle bereitgestellten Ressourcen stammen teilweise aus dem Internet. Wenn eine Verletzung Ihres Urheberrechts oder anderer Rechte und Interessen vorliegt, erläutern Sie bitte die detaillierten Gründe und legen Sie einen Nachweis des Urheberrechts oder Ihrer Rechte und Interessen vor und senden Sie ihn dann an die E-Mail-Adresse: [email protected] Wir werden die Angelegenheit so schnell wie möglich für Sie erledigen.

Copyright© 2022 湘ICP备2022001581号-3