Yaml: फ़ीचर अनुरोध: json.RawMessage समकक्ष

मैं इसे +1 करना चाहूंगा। मेरी परियोजनाओं में विन्यास फाइल लिखने के लिए बहुत उपयोगी होगा!

हाँ, मुझे वह भी याद आ रहा है इसलिए मैं कुछ क्षेत्रों के वास्तविक डिकोडिंग में देरी कर सकता हूं।
क्या कोई ज्ञात कामकाज है? मुझे नहीं पता कि Unmarshaller इंटरफ़ेस 1 को कैसे काम करना चाहिए।

yaml.RawMessage . के लिए +1

संपादित करें

yaml.MapSlice संरचना json.RawMessage तुलना में कहीं बेहतर समाधान प्रतीत होती है

yaml.RawMessage . के लिए +1

Yaml.RawMessage के साथ समस्या यह है कि JSON के विपरीत, YAML संदर्भ-निर्भर है। इंडेंटेशन के कारण, आसपास के डेटा को जाने बिना कच्चे YAML के एक टुकड़े को ठीक से एन्कोड नहीं किया जा सकता है।

क्या +1 मतदाता कृपया थोड़ा विस्तार से बता सकते हैं कि इसका उपयोग करने का इरादा कैसे है जो वर्तमान प्रणाली द्वारा हल नहीं किया गया है? शायद हम कुछ और डिजाइन कर सकते हैं जो समस्या का समाधान करता है।

@niemeyer जिस समस्या को मैंने RawMessage का उपयोग करके हल करने का इरादा किया था, मैंने बाद में MapSlice का उपयोग करके हल किया था। मैं गोलांग के लिए अपेक्षाकृत नया हूं, इसलिए यह मेरे लिए तुरंत स्पष्ट नहीं था।

मुझे लगता है कि अधिकांश समस्याएं जो लोग json.RawMessage समकक्ष के साथ हल करना चाहते हैं उन्हें yaml.MapSlice साथ हल किया जा सकता है, लेकिन इसके लिए बहुत अधिक दस्तावेज या उदाहरण उपयोग नहीं हैं। यदि इसमें और अधिक होता, तो लोग पाएंगे कि उन्हें yaml.RawMessage आवश्यकता नहीं है।

@niemeyer मेरे मामले में, मेरे पास बहुत सारी yaml कॉन्फ़िगरेशन फ़ाइलें हैं, प्रत्येक में कुछ सामान्य परिभाषा और प्लगइन सेटिंग्स शामिल हैं, प्लगइन सेटिंग्स के लिए यह प्लगइन से प्लगइन में भिन्न है, मैं पार्स में देरी करना चाहता हूं और प्लगइन कार्यान्वयन को छोड़ने के लिए RawMessage को पास करना चाहता हूं। यह।
मुझे पता है कि मैं प्लगइन सेटिंग्स को अलग yaml फ़ाइल में निकाल सकता हूं, लेकिन यह वास्तव में कष्टप्रद है मुझे उन्हें मूल yaml फ़ाइल में संदर्भित करने की आवश्यकता है।

मेरे पास ठीक वैसा ही उपयोग का मामला है जैसा @missedone

हाँ, मैपस्लाइस का उपयोग करना आसान होना चाहिए, और कोई इसे यमल में वापस मार्शल भी कर सकता है और फिर कच्चे मैसेज के सटीक अर्थशास्त्र प्राप्त करने के लिए इसे फिर से अनमर्शल कर सकता है। उस ने कहा, मैं इस मुद्दे को खुला रखूंगा ताकि हम RawMessage जैसी सुविधा के विचार पर आगे विचार कर सकें।

वैसे, सभी प्रतिक्रिया के लिए धन्यवाद!

यह बहुत अच्छा होगा यदि आपके पास मैपस्लाइस (या उस मामले के लिए एक सादा map[string]interface{} ) को सीधे एक संरचना में मैप करने की विधि हो, बिना इसे फिर से मार्शल करने की आवश्यकता के।

@dvirsky जो yaml पैकेज के लक्ष्यों से परे है, लेकिन ऐसे सीधे मैप-टू-स्ट्रक्चर रूपांतरण के लिए अन्य पैकेज उपलब्ध हैं (उदाहरण के लिए https://github.com/mitchellh/mapstruct)।

क्या यह UnmarshalYAML को लागू करने और बाद में उपयोग के लिए unmarshal फ़ंक्शन को संग्रहीत करने के लिए पर्याप्त नहीं है और तुरंत फ़ंक्शन से वापस आ जाता है? मैंने कोशिश की और यह बाद में फ़ंक्शन को कॉल करने के लिए काम करता है।

type RawMessage struct {
    unmarshal func(interface{}) error
}

func (msg *RawMessage) UnmarshalYAML(unmarshal func(interface{}) error) error {
    msg.unmarshal = unmarshal
    return nil
}

func (msg *RawMessage) Unmarshal(v interace{}) error {
    return msg.unmarshal(v)
}

फिर आप बाद में RawMessage.Unmarshal(v) कॉल कर सकते हैं और वास्तविक अनमर्शलिंग कर सकते हैं, है ना?

हाँ, यह वही है जो json.RawMessage जैसा भी नहीं है। समस्या यह है कि बीएसओएन और जेसन के विपरीत, आप इसे वापस मार्शल नहीं कर सकते हैं, क्योंकि यम मार्शलिंग संदर्भ संवेदनशील है।

हालांकि, यह संभव है कि हम जिस दिशा में जाएंगे। हमें मार्शलिंग पक्ष पर कुछ और काम करने की आवश्यकता होगी।

सच है, मुझे केवल अनमर्शलिंग को स्थगित करने की आवश्यकता थी, वास्तव में मार्शलिंग के बारे में नहीं सोच रहा था, लेकिन निश्चित रूप से, यह स्पष्ट रूप से सममित नहीं है।

और बहुत नहीं _"कच्चा",_ यदि आप देखते हैं कि मेरा क्या मतलब है। हम एक समान अमूर्तता के साथ समाप्त होने की संभावना रखते हैं जो आलसी ढंग से अनमर्शल और री-मार्शल उचित रूप से कर सकता है, लेकिन पाठ तक सीधे पहुंच प्रदान नहीं करता है।

हां।

क्या yaml.MapSlice का उपयोग करने का कोई अच्छा उदाहरण है?

मैं json.RawMessage का उपयोग करना चाहता था जिसके लिए YAML आउटपुट के बीच में एक जेसन डिक्शनरी होना था। वह अभी भी मान्य यमल है। उदाहरण के लिए इसे आउटपुट करने के लिए:

foo:
  bar: { "a" : 1 }
  baz:
    b: 2

केवल map[string]interface{} प्रकारों का उपयोग करके कोड इस तरह दिखेगा (अवांछित):

topdata := make(map[string]interface{})
foodata := make(map[string]interface{})
topdata["foo"] = foodata
foodata["bar"] = json.RawMessage(`{ "a" : 1 }`)
foodata["baz"] = map[string]interface{}{ "b" : 2 }
enc, _ := yaml.Marshal(topdata)
println(enc)

इसके बजाय, json.RawMessage को बाइट्स के एक स्लाइस के रूप में और प्रत्येक बाइट आउटपुट को एक पूर्णांक तत्व के रूप में व्याख्यायित किया जाता है।

इस पैकेज को कम से कम ऊपर दिए गए आउटपुट को करने के किसी न किसी तरीके का समर्थन करना चाहिए। जहाँ तक मैं बता सकता हूँ यह अभी संभव नहीं है।

मेरे पास कुछ विचार हैं कि यह कैसे काम कर सकता है। यह संभव है कि YAML json.RawMessage के समतुल्य YAML "ईवेंट्स" (जैसे मैप स्टार्ट, स्केलर, सीक्वेंस एंड, आदि) का एक पार्सेड सीक्वेंस हो सकता है, जिसे बाद में संदर्भ-असंवेदनशील तरीके से मार्शल और अनमर्शल किया जा सकता है।

+1
मुझे इसकी आवश्यकता है

सुनिश्चित नहीं है कि यह मदद करने वाला है, लेकिन हमने अपने मामले में ऐसा करना शुरू कर दिया है:

var configData = `
name: test
version: 0
plugins:
  http:
    user: joe
    url: https://test.com
  region:
    name: oz
`

type Config struct {
    Name    string `yaml:"name"`
    Version string `yaml:"version"`
    Plugins map[string]interface{} `yaml:"plugins"`
}

// custom plugins can be defined outside of this package
type HttpPlugin struct {
    User string `yaml:"user"`
    Url  string `yaml:"url"`
}

type RegionPlugin struct {
    Name string `yaml:"name"`
}

func TestABC(t *testing.T) {

    var config Config
    err := yaml.Unmarshal([]byte(configData), &config)
    require.NoError(t, err)
    fmt.Printf("unmarshaled config:\n%+v\n\n", config)

    // again custom plugin can be defined outside of this package
    var http HttpPlugin
    err = UnmarshalPlugin(config.Plugins["http"], &http)
    require.NoError(t, err)
    fmt.Printf("unmarshaled http plugin:\n%+v\n", http)

    var region RegionPlugin
    err = UnmarshalPlugin(config.Plugins["region"], &region)
    require.NoError(t, err)
    fmt.Printf("unmarshal region plugin:\n%+v\n", region)
}

// takes interface, marshals back to []byte, then unmarshals to desired struct
func UnmarshalPlugin(pluginIn, pluginOut interface{}) error {

    b, err := yaml.Marshal(pluginIn)
    if err != nil {
        return err
    }
    return yaml.Unmarshal(b, pluginOut)
}

मूल रूप से कच्चे संदेश के बजाय map[string]interface{} उपयोग करें, और UnmarshalPlugin

@ pete911 यह एक अच्छा विचार है, यह मेरे लिए काम कर सकता है, धन्यवाद!

हालांकि, एक प्रकार json.RawMessage (जिसका नाम संभवतः yaml.RawMessage होगा) का स्वागत किया जाएगा।

+1
मुझे इसकी आवश्यकता है।

+1

मैंने अभी-अभी @tchap द्वारा प्रस्तावित विधि की कोशिश की है और इसने पूरी तरह से काम किया है! यदि इसे आधिकारिक yaml पैकेज में शामिल किया जा सकता है, तो कम से कम मेरी तरफ से RawMessage की आवश्यकता दूर हो जाती है :)

आप ऐसे RawMessage के लिए एक स्ट्रिंग फ़ील्ड परिभाषित कर सकते हैं। फिर, अपनी yaml फ़ाइल में, उस फ़ील्ड के मान के रूप में एक बहु-पंक्ति स्ट्रिंग लिखें।

संदर्भ: https://stackoverflow.com/a/21699210/1033539

+1