@ -62,7 +62,7 @@ When Go is encoding a particular type to JSON, it looks to see if the type has a
Here is the interface
```
```golang
type Marshaler interface {
MarshalJSON() ([]byte, error)
}
@ -94,3 +94,143 @@ Enveloping response data like this isn’t strictly necessary, and whether you c
1. Including a key name (like "movie") at the top-level of the JSON helps make the response more self-documenting. For any humans who see the response out of context, it is a bit easier to understand what the data relates to.
2. It reduces the risk of errors on the client side, because it’s harder to accidentally process one response thinking that it is something different. To get at the data, a client must explicitly reference it via the "movie" key.
3. If we always envelope the data returned by our API, then we mitigate a security vulnerability in older browsers which can arise if you return a JSON array as a response.
## Decoding JSON
The `json.Unmarshal()` is an alternative, but less performant and more verbose method of decoding json compared to `json.NewDecoder().Decode()`. It is preferable to use the `Decode` implementation.
- When calling Decode() you must pass a non-nil pointer as the target decode destination. If you don’t use a pointer, it will return a json.InvalidUnmarshalError error at runtime.
- If the target decode destination is a struct — like in our case — the struct fields must be exported (start with a capital letter). Just like with encoding, they need to be exported so that they’re visible to the encoding/json package.
- When decoding a JSON object into a struct, the key/value pairs in the JSON are mapped to the struct fields based on the struct tag names. If there is no matching struct tag, Go will attempt to decode the value into a field that matches the key name (exact matches are preferred, but it will fall back to a case-insensitive match). Any JSON key/value pairs which cannot be successfully mapped to the struct fields will be silently ignored.
- There is no need to close r.Body after it has been read. This will be done automatically by Go’s http.Server, so you don’t have to.
A note on null and decoding. If the struct we are decoding to contains pointers, then the value of null will be mapped to a nil pointer. In a non-pointer struct the value will be the zero value of the type.
```golang
type Person struct {
Name *string `json:"name"` // nil if null
Age *int `json:"age"` // nil if null
}
```
vs
```golang
type Person struct {
Name string `json:"name"` // "" if null
Age int `json:"age"` // 0 if null
}
```
### JSON Decoding Nuances
#### Decoding into Go arrays
When you’re decoding a JSON array into a Go array (not a slice) there are a couple of important behaviors to be aware of:
- If the Go array is smaller than the JSON array, then the additional JSON array elements are silently discarded.
- If the Go array is larger than the JSON array, then the additional Go array elements are set to their zero values.
#### Partial JSON decoding
If you have a lot of JSON input to process and only need a small part of it, it’s often possible to leverage the json.RawMessage type to help deal with this. For example:
```golang
// Let's say that the only thing we're interested in is processing the "genres" array in
// We can then access the JSON "genres" value from the map and decode it as normal using
// the json.Unmarshal() function.
var genres []string
err = json.Unmarshal(m["genres"], &genres)
if err != nil {
log.Fatal(err)
}
fmt.Printf("genres: %v\n", genres)
```
#### Decoding into any types
It’s possible to decode JSON values into an `any` type. When you do this, the underlying value that the `any` type holds will depend on the type of the JSON value being decoded.
Decoding into an any type can be useful in situations where:
- You don’t know in advance exactly what you’re decoding.
- You need to decode JSON arrays which contain items with different JSON types.
- The key/value pair in a JSON object doesn’t always contain values with the same JSON type.
When you decode a JSON number into an any type the value will have the underlying type `float64` — even if it is an integer in the original JSON. If you want to get the value as an integer (instead of a `float64`) you should call the UseNumber() method on your `json.Decoder` instance before decoding. This will cause all JSON numbers to be decoded to the underlying type `json.Number` instead of `float64`.
The `json.Number` type then provides an `Int64()` method that you can call to get the number as an `int64`, or the `String()` method to get the number as a `string`. For example:
```
js := `10`
var n any
dec := json.NewDecoder(strings.NewReader(js))
dec.UseNumber() // Call the UseNumber() method on the decoder before using it.
err := dec.Decode(&n)
if err != nil {
log.Fatal(err)
}
// Type assert the any value to a json.Number, and then call the Int64() method
// to get the number as a Go int64.
nInt64, err := n.(json.Number).Int64()
if err != nil {
log.Fatal(err)
}
// Likewise, you can use the String() method to get the number as a Go string.
Using the struct tag `json:"-"` on a struct field will cause it to be ignored when decoding JSON, even if the JSON input contains a corresponding key/value pair. The `omitzero` and `omitempty` struct tag directives do not have any effect on JSON decoding behavior.
