कैसे डेटा struct पैरामीटर के रूप में golang में

Question

एक्सएमएल Json

package main 

import (
    "encoding/json" 
    "encoding/xml" 
    "fmt" 
) 

type Persons struct { 
    Person []struct { 
     Name string 
     Age int 
    } 
} 
type Places struct { 
    Place []struct { 
     Name string 
     Country string 
    } 
} 

type Parks struct { 
    Park struct { 
     Name  []string 
     Capacity []int 
    } 
} 

const personXml = ` 
    <Persons> 
     <Person><Name>Koti</Name><Age>30</Age></Person> 
     <Person><Name>Kanna</Name><Age>29</Age></Person> 
    </Persons> 
` 

const placeXml = ` 
    <Places> 
     <Place><Name>Chennai</Name><Country>India</Country></Place> 
     <Place><Name>London</Name><Country>UK</Country></Place> 
    </Places> 
` 

const parkXml = ` 
    <Parks> 
     <Park><Name>National Park</Name><Capacity>10000</Capacity></Park> 
     <Park>Asian Park</Name><Capacity>20000</Capacity></Park> 
    </Parks> 
` 

func WhatIamUsing() { 
    var persons Persons 
    xml.Unmarshal([]byte(personXml), &persons) 
    per, _ := json.Marshal(persons) 
    fmt.Printf("%s\n", per) 

    var places Places 
    xml.Unmarshal([]byte(placeXml), &places) 
    pla, _ := json.Marshal(places) 
    fmt.Printf("%s\n", pla) 

    var parks Parks 
    xml.Unmarshal([]byte(parkXml), &parks) 
    par, _ := json.Marshal(parks) 
    fmt.Printf("%s\n", par) 
} 

को पारित करने के लिए क्या मैं चाहता हूँ एक सामान्य समारोह जो एक्सएमएल स्ट्रिंग और dataStruct लेता है और एक JSON उत्पादन देता है। लेकिन नीचे फंक्शन एक त्रुटि फेंक रहा है इसे कैसे लागू करें?

func Xml2Json(xmlString string, DataStruct interface{}) (jsobj string, err error) { 
    var dataStruct DataStruct 
    xml.Unmarshal([]byte(personXml), &dataStruct) 
    js, _ := json.Marshal(dataStruct) 
    return fmt.Sprintf("%s\n", js), nil 
} 

func main() { 
    jsonstring, _ := Xml2Json(personXml, Persons) 
} 

त्रुटि संदेश:

prog.go: 73: 80: http://play.golang.org/p/vayb0bawKx

: प्रकार व्यक्तियों एक अभिव्यक्ति

goplay लिंक नहीं है DataStruct एक प्रकार

prog.go नहीं है

Answer 1

आप एक इंटरफेस में एक प्रकार (जैसे Persons) स्टोर नहीं कर सकते हैं। आप अपने फ़ंक्शन में reflect.Type पास कर सकते हैं। फिर, आपकी कॉल Xml2Json(personXml, reflect.TypeOf(Persons)) की तरह दिखेगी जो मेरी राय में काफी बदसूरत है।

बेहतर दृष्टिकोण शायद है:

func Xml2Json(xmlString string, value interface{}) (string, error) { 
    if err := xml.Unmarshal([]byte(xmlString), value); err != nil { 
     return "", err 
    } 
    js, err := json.Marshal(value) 
    if err != nil { 
     return "", err 
    } 
    return string(js), nil 
} 

आप Xml2Json(personXml, new(Persons)) के साथ इस समारोह का उपयोग कर सकते है अगर आप मूल्य अपने आप में कोई दिलचस्पी नहीं कर रहे हैं, और

var persons Persons 
Xml2Json(personXML, &persons) 

आप भी struct प्राप्त करना चाहते हैं जब बाद में प्रसंस्करण के लिए मूल्य।

Answer 2

फ़ंक्शन Xml2JsonDataStruct नामक पैरामीटर घोषित करता है। उसी दायरे में पहचानकर्ता DataStruct किसी प्रकार का नाम इंगित नहीं कर सकता है। यदि आप उसी दायरे में DataStruct प्रकार का उपयोग करना चाहते हैं, तो आपको अपने पैरामीटर को अलग-अलग नाम देना होगा।

मुख्य कार्य में समस्या यह है कि फ़ंक्शन कॉल वाक्यविन्यास कोष्ठक के भीतर एक अभिव्यक्ति सूची की अपेक्षा करता है। वहां आप टाइप नाम पास कर रहे हैं, जो स्पष्ट रूप से अभिव्यक्ति नहीं हो सकता है।

तो अपने प्रश्न का उत्तर देने के लिए: नहीं, आप किसी फ़ंक्शन के लिए तर्क के रूप में एक प्रकार को पास नहीं कर सकते हैं।

package main 

import (
     "encoding/json" 
     "encoding/xml" 
     "fmt" 
     "log" 
) 

type Persons struct { 
     Person []struct { 
       Name string 
       Age int 
     } 
} 

type Places struct { 
     Place []struct { 
       Name string 
       Country string 
     } 
} 

type Parks struct { 
     Park struct { 
       Name  []string 
       Capacity []int 
     } 
} 

const (
     personXml = ` 
    <Persons> 
     <Person><Name>Koti</Name><Age>30</Age></Person> 
     <Person><Name>Kanna</Name><Age>29</Age></Person> 
    </Persons> 
` 
     placeXml = ` 
    <Places> 
     <Place><Name>Chennai</Name><Country>India</Country></Place> 
     <Place><Name>London</Name><Country>UK</Country></Place> 
    </Places> 
` 

     parkXml = ` 
    <Parks> 
     <Park><Name>National Park</Name><Capacity>10000</Capacity></Park> 
     <Park><Name>Asian Park</Name><Capacity>20000</Capacity></Park> 
    </Parks> 
` 
) 

func Xml2Json(xmlString string, DataStruct interface{}) (jsobj string, err error) { 
     if err = xml.Unmarshal([]byte(xmlString), DataStruct); err != nil { 
       return 
     } 

     js, err := json.Marshal(DataStruct) 
     if err != nil { 
       return 
     } 

     return fmt.Sprintf("%s", js), nil 
} 

func main() { 
     var p Persons 
     jsonstring, err := Xml2Json(personXml, &p) 
     if err != nil { 
       log.Fatal(err) 
     } 

     fmt.Println(jsonstring) 

     var q Places 
     jsonstring, err = Xml2Json(placeXml, &q) 
     if err != nil { 
       log.Fatal(err) 
     } 

     fmt.Println(jsonstring) 

     var r Parks 
     jsonstring, err = Xml2Json(parkXml, &r) 
     if err != nil { 
       log.Fatal(err) 
     } 

     fmt.Println(jsonstring) 

} 

Playground

---

आउटपुट::

लेकिन आप प्रभाव के बारे में आप कर रहे हैं पाने के लिए (इस मामले में इस तरह के उदाहरण के लिए सूचक में) एक प्रकार का एक उदाहरण पारित कर सकते हैं

{"Person":[{"Name":"Koti","Age":30},{"Name":"Kanna","Age":29}]} 
{"Place":[{"Name":"Chennai","Country":"India"},{"Name":"London","Country":"UK"}]} 
{"Park":{"Name":["National Park","Asian Park"],"Capacity":[10000,20000]}}