[ad_1]
\n<\/p>\n
Just use Consider how As the documentation goes on to say, if To unmarshal JSON into an interface value, Unmarshal stores one of these in the interface value:<\/p>\n but if Its actual implementation<\/a> is particularly complex because it’s optimized to do the de-JSON-ification and the assignment into the target object at the same time. In principle, though, it’s mostly a big type-switch on the underlying (concrete) type of the interface value.<\/p>\n Meanwhile, what you are describing in your question is that you will first deserialize into generic JSON\u2014which really means a variable of type and you would then call<\/em> this code by writing:<\/p>\n so that you know that JSON object key “Field1” should fill in your Field1 field with an integer, and JSON object key “Field2” should fill in your Field2 field with a string:<\/p>\n But this is silly. You can just write:<\/p>\n (or even omit the tags since the field’s names are the default json tags), and then do this:<\/p>\n In other words, just let Jump down to around line 660 of There are some mechanics to handle corner cases (including the fact that If all goes well, it gets into the JSON key-and-value scanning loop starting at line 720 ( If we’re decoding into a If we’re decoding into a map, we will decode the value into a temporary first, then store it into the map after decoding. It would be nice to share this with the struct-field storing, but we need a different We’re now ready to convert the actual value to the target type, so we go back to the JSON bytes and consume the colon If all that worked, and we’re decoding to a map, we may now need to massage the type of the temporary, find the real key, and store the converted value into the map. That’s what lines 830 ( 1<\/sup>To find fields, we first look over at json.Unmarshal<\/code>. You can wrap it lightly, using your transport, and call json.Unmarshal<\/code> (or with a json.Decoder<\/code> instance, use d.Decode<\/code>) on your prebuilt JSON bytes and the v interface{}<\/code> argument from your caller.<\/p>\nSomewhat longer, with an example<\/h3>\n
json.Unmarshal<\/code><\/a> does its own magic. Its first argument is the JSON (data []byte<\/code>), but its second argument is of type interface{}<\/code>:<\/p>\nfunc Unmarshal(data []byte, v interface{}) error\n<\/code><\/pre>\nv<\/code> really is<\/em> just an interface{}<\/code>:<\/p>\n\n
bool, for JSON booleans\nfloat64, for JSON numbers\nstring, for JSON strings\n[]interface{}, for JSON arrays\nmap[string]interface{}, for JSON objects\nnil for JSON null\n<\/code><\/pre>\n<\/blockquote>\nv<\/code> has an underlying concrete type<\/em>, such as type myData struct { ... }<\/code>, it’s much fancier. It only does the above if v<\/code>‘s underlying type is<\/em> interface{}<\/code>.<\/p>\ninterface{}<\/code>\u2014and then do your own assignment out<\/em> of this pre-decoded JSON into another variable of type interface{}<\/code>, where the type signature of your own decoder would be:<\/p>\nfunc xxxDecoder(\/* maybe some args here, *\/ v interface{}) error {\n var predecoded interface{}\n\n \/\/ get some json bytes from somewhere into variable `data`\n err := json.Unmarshal(data, &predecoded)\n\n \/\/ now emulate json.Unmarshal by getting field names and assigning\n ... this is the hard part ...\n}\n<\/code><\/pre>\ntype myData struct {\n Field1 int `xxx:\"Field1\"`\n Field2 string `xxx:\"Field2\"`\n}\n<\/code><\/pre>\nfunc whatever() {\n var x myData\n err := xxxDecode(..., &x)\n if err != nil { ... handle error ... }\n ... use x.Field1 and x.Field2 ...\n}\n<\/code><\/pre>\ntype myData struct {\n Field1 int `json:\"Field1\"`\n Field2 string `json:\"Field2\"`\n}\n<\/code><\/pre>\nfunc xxxDecode(..., v interface{}) error {\n ... get data bytes as before ...\n return json.Unmarshal(data, v)\n}\n<\/code><\/pre>\njson.Unmarshal<\/code> do all the work<\/strong> by providing json<\/em> tags in the data structures in question. You still get\u2014and transmit across your special transport\u2014the JSON data bytes from<\/em> json.Marshal<\/code> and json.Unmarshal<\/code>. You do the transmitting and receiving. json.Marshal<\/code> and json.Unmarshal<\/code> do all the hard work: you don’t have to touch it!<\/p>\nIt’s still fun to see how
Json.Unmarshal<\/code> works<\/h3>\nencoding\/json\/decode.go<\/code><\/a>, where you will find the thing that handles a JSON “object” ({<\/code> followed by either }<\/code> or a string that represents a key), for instance:<\/p>\nfunc (d *decodeState) object(v reflect.Value) error {\n<\/code><\/pre>\nv<\/code> might not be settable and\/or might be a pointer that should be followed), then it makes sure that v<\/code> is either a map[T1]T2<\/code> or struct<\/code>, and if it is a map, that it’s suitable\u2014that both T1<\/code> and T2<\/code> will work when decoding the “key”:value items in the object.<\/p>\nfor {<\/code>, which will break or return as appropriate). On each trip through this loop, the code reads the JSON key first, leaving the :<\/code> and value part for later.<\/p>\nstruct<\/code>, the decoder now uses the struct’s fields\u2014names and json:\"...\"<\/code> tags\u2014to find a reflect.Value<\/code> that we’ll use to store right into the field.1<\/sup> This is subv<\/code>, found by calling v.Field(i)<\/code> for the right i<\/code>, with some slightly complicated goo to handle embedded anonymous structs<\/code> and pointer-following. The core of this is just subv = v.Field(i)<\/code>, though, where i<\/code> is whichever field this key names, within the struct. So subv<\/code> is now a reflect.Value<\/code> that represents the actual struct instance’s value, which we should set once we’ve decoded the value part of the JSON key-value pair.<\/p>\nreflect<\/code> function to do the store into the map: v.SetMapIndex<\/code><\/a>, where v<\/code> is the reflect.Value<\/code> of the map. That’s why for a map, subv<\/code> points to a temporary Elem<\/code>.<\/p>\n:<\/code> character and read the JSON value. We get the value and store it into our storage location (subv<\/code>). This is the code starting at line 809 (if destring {<\/code>). The actual assigning is done through the decoder functions (d.literalStore<\/code> at line 908, or d.value<\/code> at line 412) and these actually decode the JSON value while doing the storing. Note that only d.literalStore<\/code> really stores the value\u2014d.value<\/code> calls on d.array<\/code>, d.object<\/code>, or d.literalStore<\/code> to do the work recursively if needed.<\/p>\nd.literalStore<\/code> therefore contains many switch v.Kind()<\/code>s: it parses a null<\/code> or a true<\/code> or false<\/code> or an integer or a string or an array, then makes sure it can store the resulting value into v.Kind()<\/code>, and chooses how<\/em> to store that resulting value into v.Kind()<\/code> based on the combination of what it just decoded, and the actual v.Kind()<\/code>. So there’s a bit of a combinatorial explosion here, but it gets the job done.<\/p>\nif v.Kind() == reflect.Map {<\/code>) through the final close brace at 867 are about.<\/p>\n
\nencoding\/json\/encode.go<\/code> to find cachedTypeFields<\/code>. It is a caching version of typeFields<\/code><\/a>. This is where the json tags are found and put into a slice. The result is cached via cachedTypeFields<\/code> in a map indexed by the reflect-type value of the struct<\/code> type. So what we get is a slow lookup the first time we use a struct<\/code> type, then a fast lookup afterwards, to get a slice of information about how to do the decoding. This slice-of-information maps from json-tag-or-field name to: field; type; whether it’s a sub-field of an anonymous structure; and so on: everything we will need to know to decode it properly\u2014or to encode it, on the encoding side. (I didn’t really look closely at this code.)<\/p>\n<\/p><\/div>\n