मानचित्र को संरचना में परिवर्तित करना

Question 1

मैं गो में एक जेनेरिक विधि बनाने की कोशिश कर रहा हूं जो ए structसे डेटा का उपयोग करेगा map[string]interface{}। उदाहरण के लिए, विधि हस्ताक्षर और उपयोग की तरह लग सकता है:

func FillStruct(data map[string]interface{}, result interface{}) {
    ...
}

type MyStruct struct {
    Name string
    Age  int64
}

myData := make(map[string]interface{})
myData["Name"] = "Tony"
myData["Age"]  = 23

result := &MyStruct{}
FillStruct(myData, result)

// result now has Name set to "Tony" and Age set to 23

मुझे पता है कि यह एक मध्यस्थ के रूप में JSON का उपयोग करके किया जा सकता है; क्या ऐसा करने का एक और अधिक कुशल तरीका है?

Question 2

सबसे सरल तरीका होगा https://github.com/mitchellh/mapstructure का उपयोग करना

import "github.com/mitchellh/mapstructure"

mapstructure.Decode(myData, &result)

यदि आप इसे स्वयं करना चाहते हैं, तो आप कुछ ऐसा कर सकते हैं:

http://play.golang.org/p/tN8mxT_V9h

func SetField(obj interface{}, name string, value interface{}) error {
    structValue := reflect.ValueOf(obj).Elem()
    structFieldValue := structValue.FieldByName(name)

    if !structFieldValue.IsValid() {
        return fmt.Errorf("No such field: %s in obj", name)
    }

    if !structFieldValue.CanSet() {
        return fmt.Errorf("Cannot set %s field value", name)
    }

    structFieldType := structFieldValue.Type()
    val := reflect.ValueOf(value)
    if structFieldType != val.Type() {
        return errors.New("Provided value type didn't match obj field type")
    }

    structFieldValue.Set(val)
    return nil
}

type MyStruct struct {
    Name string
    Age  int64
}

func (s *MyStruct) FillStruct(m map[string]interface{}) error {
    for k, v := range m {
        err := SetField(s, k, v)
        if err != nil {
            return err
        }
    }
    return nil
}

func main() {
    myData := make(map[string]interface{})
    myData["Name"] = "Tony"
    myData["Age"] = int64(23)

    result := &MyStruct{}
    err := result.FillStruct(myData)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(result)
}

Question 3

हैशिकॉर्प की https://github.com/mitchellh/mapstructure लाइब्रेरी इसे बॉक्स से बाहर करती है:

import "github.com/mitchellh/mapstructure"

mapstructure.Decode(myData, &result)

दूसरे resultपैरामीटर में संरचना का पता होना चाहिए।

Question 4

encoding/jsonपैकेज का उपयोग करने का सबसे सरल तरीका है

सिर्फ उदाहरण के लिए:

package main
import (
    "fmt"
    "encoding/json"
)

type MyAddress struct {
    House string
    School string
}
type Student struct {
    Id int64
    Name string
    Scores float32
    Address MyAddress
    Labels []string
}

func Test() {

    dict := make(map[string]interface{})
    dict["id"] = 201902181425       // int
    dict["name"] = "jackytse"       // string
    dict["scores"] = 123.456        // float
    dict["address"] = map[string]string{"house":"my house", "school":"my school"}   // map
    dict["labels"] = []string{"aries", "warmhearted", "frank"}      // slice

    jsonbody, err := json.Marshal(dict)
    if err != nil {
        // do error check
        fmt.Println(err)
        return
    }

    student := Student{}
    if err := json.Unmarshal(jsonbody, &student); err != nil {
        // do error check
        fmt.Println(err)
        return
    }

    fmt.Printf("%#v\n", student)
}

func main() {
    Test()
}

Question 5

आप इसे कर सकते हैं ... यह थोड़ा बदसूरत हो सकता है और आपको मैपिंग प्रकारों के संदर्भ में कुछ परीक्षण और त्रुटि का सामना करना पड़ेगा .. लेकिन इसके मूल सार का पता लगाता है:

func FillStruct(data map[string]interface{}, result interface{}) {
    t := reflect.ValueOf(result).Elem()
    for k, v := range data {
        val := t.FieldByName(k)
        val.Set(reflect.ValueOf(v))
    }
}

कार्य नमूना: http://play.golang.org/p/PYHz63sbvL

Question 6

मैं डेव के उत्तर को अनुकूलित करता हूं, और एक पुनरावर्ती सुविधा जोड़ता हूं। मैं अभी भी अधिक उपयोगकर्ता के अनुकूल संस्करण पर काम कर रहा हूं। उदाहरण के लिए, नक्शे में एक संख्या स्ट्रिंग को संरचना में इंट में परिवर्तित करने में सक्षम होना चाहिए।

package main

import (
    "fmt"
    "reflect"
)

func SetField(obj interface{}, name string, value interface{}) error {

    structValue := reflect.ValueOf(obj).Elem()
    fieldVal := structValue.FieldByName(name)

    if !fieldVal.IsValid() {
        return fmt.Errorf("No such field: %s in obj", name)
    }

    if !fieldVal.CanSet() {
        return fmt.Errorf("Cannot set %s field value", name)
    }

    val := reflect.ValueOf(value)

    if fieldVal.Type() != val.Type() {

        if m,ok := value.(map[string]interface{}); ok {

            // if field value is struct
            if fieldVal.Kind() == reflect.Struct {
                return FillStruct(m, fieldVal.Addr().Interface())
            }

            // if field value is a pointer to struct
            if fieldVal.Kind()==reflect.Ptr && fieldVal.Type().Elem().Kind() == reflect.Struct {
                if fieldVal.IsNil() {
                    fieldVal.Set(reflect.New(fieldVal.Type().Elem()))
                }
                // fmt.Printf("recursive: %v %v\n", m,fieldVal.Interface())
                return FillStruct(m, fieldVal.Interface())
            }

        }

        return fmt.Errorf("Provided value type didn't match obj field type")
    }

    fieldVal.Set(val)
    return nil

}

func FillStruct(m map[string]interface{}, s interface{}) error {
    for k, v := range m {
        err := SetField(s, k, v)
        if err != nil {
            return err
        }
    }
    return nil
}

type OtherStruct struct {
    Name string
    Age  int64
}


type MyStruct struct {
    Name string
    Age  int64
    OtherStruct *OtherStruct
}



func main() {
    myData := make(map[string]interface{})
    myData["Name"]        = "Tony"
    myData["Age"]         = int64(23)
    OtherStruct := make(map[string]interface{})
    myData["OtherStruct"] = OtherStruct
    OtherStruct["Name"]   = "roxma"
    OtherStruct["Age"]    = int64(23)

    result := &MyStruct{}
    err := FillStruct(myData,result)
    fmt.Println(err)
    fmt.Printf("%v %v\n",result,result.OtherStruct)
}

Question 7

दो चरण हैं:

JSON बाइट में इंटरफ़ेस बदलें
JSON बाइट को संरचना में बदलें

नीचे एक उदाहरण है:

dbByte, _ := json.Marshal(dbContent)
_ = json.Unmarshal(dbByte, &MyStruct)