गो में संरचनाओं के एक सीमित सेट में YAML फ़ील्ड को गतिशील रूप से पार्स करें

परिचय

गो में एक संरचना में YAML को पार्स करना सीधा हो सकता है। हालाँकि, जब एक YAML फ़ील्ड कई संभावित संरचनाओं का प्रतिनिधित्व कर सकता है, तो कार्य अधिक जटिल हो जाता है। यह लेख गो के YAML पैकेज का उपयोग करके एक गतिशील दृष्टिकोण की खोज करता है। संरचना { अनमर्शल फंक(इंटरफ़ेस{}) त्रुटि } func (n *yamlNode) अनमर्शलYAML(अनमर्शल func(इंटरफ़ेस{}) त्रुटि) त्रुटि { n.अनमर्शल = अनमर्शल वापसी शून्य } विशिष्ट संरचना टाइप करें { दयालु स्ट्रिंग `yaml:"kind"` विशेष इंटरफ़ेस{} `yaml:"-" }

func (s *Spec) UnmarshalYAML(unmarshal func(interface{}) त्रुटि) त्रुटि { एस स्पेक टाइप करें टी संरचना टाइप करें { एस `यमल:",इनलाइन"` विशिष्ट yamlNode `yaml:"spec"` } obj := &T{} यदि त्रुटि := अनमर्शल(ओबीजे); त्रुटि != शून्य { ग़लती से वापसी } *s = युक्ति(obj.S) स्विच एस प्रकार { मामला "फू": एस.स्पेक = नया(फू) मामला "बार": s.Spec = नया (बार) गलती करना: घबराहट("कुछ अज्ञात") } वापसी obj.Spec.unmarshal(s.Spec) }

YAML v3 के साथ डायनामिक अनमर्शलिंग

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

func (s *Spec) UnmarshalYAML(n *yaml.Node) त्रुटि { एस स्पेक टाइप करें टी संरचना टाइप करें { *एस `यमल:",इनलाइन"` Spec yaml.Node `yaml:"spec"` } obj := &T{S: (*S)(s)} यदि त्रुटि := n.Decode(obj); त्रुटि != शून्य { ग़लती से वापसी } स्विच एस प्रकार { मामला "फू": एस.स्पेक = नया(फू) मामला "बार": s.Spec = नया (बार) गलती करना: घबराहट("कुछ अज्ञात") } वापसी obj.Spec.Decode(s.Spec) }

निष्कर्ष

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