] हालांकि, कभी -कभी एक YAML फ़ाइल में ऐसे क्षेत्र हो सकते हैं जिन्हें विभिन्न प्रकार की संरचनाओं द्वारा प्रतिनिधित्व करने की आवश्यकता होती है। यह जटिल कोड और अव्यवस्थित yaml फ़ाइलों को जन्म दे सकता है। कल्पना: fooval: 4

प्रकार: "बार" कल्पना: Barval: 5

और पार्सिंग के लिए संबंधित संरचनाएं:

प्रकार की संरचना { दयालु स्ट्रिंग `yaml:" दयालु "` स्पेक इंटरफ़ेस {} `yaml:" कल्पना "` } टाइप फू स्ट्रक्चर { Fooval int `yaml:" fooval "` } टाइप बार स्ट्रक्चर { Barval int `yaml:" Barval "` }

एक दृष्टिकोण एक मानचित्र का उपयोग करना है [स्ट्रिंग] इंटरफ़ेस {} कल्पना फ़ील्ड के लिए प्रकार के रूप में। हालाँकि, इस दृष्टिकोण से अतिरिक्त जटिलता और मेमोरी की खपत हो सकती है, विशेष रूप से बड़ी YAML फ़ाइलों के लिए। Unmarshal func (इंटरफ़ेस {}) त्रुटि } func (n *yamlnode) unmarshalyaml (unmarshal func (इंटरफ़ेस {}) त्रुटि) त्रुटि { n.unmarshal = unmarshal वापसी निल }

kind: "foo"
spec:
  fooVal: 4

kind: "bar"
spec:
  barVal: 5

इन परिवर्तनों के साथ, कल्पना के लिए unmarshalyaml फ़ंक्शन गतिशील रूप से एक विशिष्ट संरचना प्रकार में कल्पना फ़ील्ड को पार्स और unmarshal कर सकता है:

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"`
}

func (s *spec) unmarshalyaml (unmarshal func (intface {}) त्रुटि { टाइप एस स्पेक टाइप टी स्ट्रक्चर { S `yaml:", इनलाइन "` कल्पना yamlnode `yaml:" कल्पना "` } obj: = & t {} यदि गलत: = unmarshal (obj); irr! = nil { वापसी की कमी } *एस = कल्पना (obj.s) स्विच S.Kind { केस "फू": Sspec = नया (FOO) मामला "बार": sspec = नया (बार) गलती करना: घबराहट ("दयालु अज्ञात") } obj.spec.unmarshal (S.Spec) लौटें …