Golang unmarshal json that starts as an array - json

I'm trying to unmarshal this json https://www.reddit.com/r/videos/comments/3vgdsb/recruitment_2016.json
It starts as an array of two different objects, and I only need data on the second object.
I want to retrieve the comments body, it doesn't give me any error when i'm trying to decode it, but it doesn't capture the data I want.
This is the output I get from running this:
//Response struct when initialized: []
//Response struct decoded: [{{{[]}}} {{{[]}}}]
////
type Response []struct {
Parent struct {
Data struct {
Children []struct {
Com Comment
}
}
}
}
type Comment struct {
Name string `json:"body"`
}
func init() {
http.HandleFunc("/api/getcomments", getComments)
}
func getComments(w http.ResponseWriter, r *http.Request) {
url := "https://www.reddit.com/r/videos/comments/3vgdsb/recruitment_2016.json"
c := appengine.NewContext(r)
client := urlfetch.Client(c)
resp, err := client.Get(url)
if err != nil { fmt.Fprint(w, "Error client.Get(): ", err) }
re := new(Response)
fmt.Fprint(w, "Response struct: ", re, "\n")
errTwo := json.NewDecoder(resp.Body).Decode(&re)
if errTwo != nil { fmt.Fprint(w, "Error decoding: ", errTwo, "\n") }
fmt.Fprint(w, "Response struct: ", re)
}

For everyone that is struggling to create the right structure for JSON unmarshalling, here's a cool website that convert any JSON to the right Go struct: JSON-to-Go

The json data you are unmarshaling does not conform with your data, and if the names of the fields are not like in your struct, you should use struct tags as well. It should be more like this:
type Response []struct {
Kind string `json:"kind"`
Data struct {
Children []struct {
Data struct {
Replies []struct {
// whatever...
} `json:"replies"`
} `json:"data"`
} `json:"children"`
} `json:"data"`
}
}
Of course I'd replace the inline types with real, named types, but I'm just making a point here in regards to the data hierarchy.
Goddamn, that's some ugly bloated JSON BTW.

Related

Can't unmarshal json with base64 encoded byte slice in go

I'm having a hard time unmarshalling a struct that is sent to me from an AWS lambda function.
All of the pkidata fields are empty no matter what I do. I created this code sample to isolate the process :
package main
import (
"encoding/base64"
"encoding/json"
"fmt"
)
func main() {
mystring := `{"error":{"errormessage": "errormessagetest", "errortype": "errortypetest"}, "pkidata":{"certificate":"Q2VydGlmaWNhdGU6CiAgICBEYXRhOgogICAgICAgIFZlcnNpb246IDMgKDB4MikKICAgICAgICBTZXJpYWwgTnVtYmVyOgogICAgICAgICAgICBhYTo5MzpiMTo4MDphYjpiYTplYzo5ZTo4MzpmOTo2OTo5NToyNDpkZjo5Njo2OQogICAgU2lnbmF0dXJlIEFsZ29yaXRobTogc2hhMjU2V2l0aFJTQUVuY3J5cHRpb24KICAgICAgICBJc3N1ZXI6IENOPXJhcGhvZXN0ZXIKICAgICAgICBWYWxpZGl0eQogICAgICAgICAgICBOb3QgQmVmb3JlOiBNYXIgMjcgMTk6NDM6MTQgMjAyMiBHTVQKICAgICAgICAgICAgTm90IEFmdGVyIDogSnVuIDI5IDE5OjQzOjE0IDIwMjQgR01UCiAgICAgICAgU3ViamVjdDogQ049cmFwaG9lc3RlcgogICAgICAgIFN1YmplY3QgUHVibGljIEtleSBJbmZvOgogICAgICAgICAgICBQdWJsaWMgS2V5IEFsZ29yaXRobTogcnNhRW5jcnlwdGlvbgogICAgICAgICAgICAgICAgUHVibGljLUtleTogKDIwNDggYml0KQogICAgICAgICAgICAgICAgTW9kdWx1czoKICAgICAgICAgICAgICAgICAgICAwMDpjNjplZjpkNjoxYTo0Mjo0Mjo2ZTo5MTpiODpmNTpiZjoyNToyNTpkODoKICAgICAgICAgICAgICAgICAgICBhNjo4Yjo4MzpmYjo2ZDo4MzpiNjowZTo3Mzo4ZjowYTozMjo5ZjpjNjplMjoKICAgICAgICAgICAgICAgICAgICBmMTo4Njo5NDoxMzo5MjplYjo0MTozNTo4NTpiZDo0ZDpkNzowNzo4ZTo5YjoKICAgICAgICAgICAgICAgICAgICBjYzoyYzpkMjo2Nzo5ZDpjOTo1Mzo4Yjo4ODpjZToxMTozOTpkODpkZTo3MjoKICAgICAgICAgICAgICAgICAgICBhMTphODo4MDozMDpmOTpiYTpiOTo3NTpjNTphMjoxYjpiZToyMDo3Yzo1ZjoKICAgICAgICAgICAgICAgICAgICBhMjpjZjpiNzphMjo2ODo4MzpiMzoxMTplODoyNTo3Mzo2MzoyNjphNzpiODoKICAgICAgICAgICAgICAgICAgICBjMzpjZDpjODplZTozNjphZjo4ZTo4ZjowZTo5NDowMToyMDpmZjowZTo0MToKICAgICAgICAgICAgICAgICAgICBjYjplZDpmYjo3NDowNToyZDo0NDphOToxNjoxZDo0ODpkNDphNDo3NTo0ZjoKICAgICAgICAgICAgICAgICAgICBlZjo0NDozYTphMDpmMDo1ZTo5ZTo5YjoxOTphZTo4MTozMzpkMDpkMTpmYzoKICAgICAgICAgICAgICAgICAgICA0MTphMTo1OTo5Zjo3MDoxZDphYTo3MzoyNTpiNTpiNjo3NDo2Mzo1NzpjZjoKICAgICAgICAgICAgICAgICAgICAzNTplNzpiZToyNjo1MzoxNDpkNTplNzpiMzpmYToyZDpjYzo5NToyMzo0ODoKICAgICAgICAgICAgICAgICAgICBkOTpkNTozNDplMjowNzoxYjoyNzoyMzpiZTpiODpmNzpiNTpkOTo3MDo1ZDoKICAgICAgICAgICAgICAgICAgICAyOTo4NTo3NToyYjpmYTo0MjpmNTo2Mjo1OTozZjowODo3Njo0Nzo2NjpmNzoKICAgICAgICAgICAgICAgICAgICAxYzpiYzozNzo1MjpiMDo3ODoyNzozNDo3MTo3ZTpiNjozZDowNDpjZDoyMzoKICAgICAgICAgICAgICAgICAgICAzMjphNjoxYTo2NzphNDo4ODoyYTowYTpmMjoxMjphNTo3ODpkYjpiZDpjOToKICAgICAgICAgICAgICAgICAgICA1ZToxMTo4Njo0MDpkMTo0MTplZjpkYzo2Yjo4Zjo1NjpmZDo1MjpkYTo0ZjoKICAgICAgICAgICAgICAgICAgICBiNTpmMDozYTpmZTpjNzoxMDo3ZTpjNDo3OTo2MTo1ZTpkYjo5Zjo4NjpjOToKICAgICAgICAgICAgICAgICAgICBmYjpiNwogICAgICAgICAgICAgICAgRXhwb25lbnQ6IDY1NTM3ICgweDEwMDAxKQogICAgICAgIFg1MDl2MyBleHRlbnNpb25zOgogICAgICAgICAgICBYNTA5djMgQmFzaWMgQ29uc3RyYWludHM6IAogICAgICAgICAgICAgICAgQ0E6RkFMU0UKICAgICAgICAgICAgWDUwOXYzIFN1YmplY3QgS2V5IElkZW50aWZpZXI6IAogICAgICAgICAgICAgICAgMDU6M0Y6RDk6MjE6Rjg6MUE6QjM6NDM6OEQ6QzI6NDA6NzI6OUY6MDE6NDg6MTc6NDE6Nzc6Q0U6MzkKICAgICAgICAgICAgWDUwOXYzIEF1dGhvcml0eSBLZXkgSWRlbnRpZmllcjogCiAgICAgICAgICAgICAgICBrZXlpZDozNTpCRjpBOTozRDo1RjozMzozODowQjowNjo3QzpDQTpFQzo0ODo3QzpCRTo3Njo3MzpCRTpEQjpGRQogICAgICAgICAgICAgICAgRGlyTmFtZTovQ049cmFwaG9lc3RlcgogICAgICAgICAgICAgICAgc2VyaWFsOjhGOjE3OkY1OjJBOjhBOkI0OkQwOjY5CgogICAgICAgICAgICBYNTA5djMgRXh0ZW5kZWQgS2V5IFVzYWdlOiAKICAgICAgICAgICAgICAgIFRMUyBXZWIgU2VydmVyIEF1dGhlbnRpY2F0aW9uCiAgICAgICAgICAgIFg1MDl2MyBLZXkgVXNhZ2U6IAogICAgICAgICAgICAgICAgRGlnaXRhbCBTaWduYXR1cmUsIEtleSBFbmNpcGhlcm1lbnQKICAgICAgICAgICAgWDUwOXYzIFN1YmplY3QgQWx0ZXJuYXRpdmUgTmFtZTogCiAgICAgICAgICAgICAgICBETlM6cmFwaG9lc3RlcgogICAgU2lnbmF0dXJlIEFsZ29yaXRobTogc2hhMjU2V2l0aFJTQUVuY3J5cHRpb24KICAgICAgICAgNTg6M2U6MTE6ZmQ6OWM6ZWQ6MTA6YmQ6NmM6NWE6OWY6NzY6OGY6OTc6MGE6YTY6Mzg6ODI6CiAgICAgICAgIDFhOmYwOmJlOjRiOmU4OjEwOmQ4OjNlOmFhOmFlOjIwOmNiOmMzOjI2OjY1OmU3OmI3OmM3OgogICAgICAgICBjNzo2MToxZTpjNjplMjpjYTpmODo1NTo4ZTpkODoxNjozODphZjo3ZjphZDo3Mjo1MzoxYzoKICAgICAgICAgNmE6MzI6NjE6M2U6ZDM6M2E6NWI6NTg6OTU6NDU6ZGE6MGQ6ZTg6ZjQ6NDM6ZWY6NmY6ZmM6CiAgICAgICAgIDE4OmQxOjA4OjA5OjZlOmQ5OjRmOmQ3OjljOmU2OjliOjAzOmU3OjczOjhkOjExOjNhOjkyOgogICAgICAgICBiMDozYTpjOTpiNDo2MjpmNDphODpiMTphMDo0MzpkMzplODoyZjphZDo5Yjo4ZjoyZjpjZjoKICAgICAgICAgZTA6ZTY6YzE6MWM6MDc6N2E6OWY6YjM6NTI6NWU6MzM6ZWU6MjE6NjY6YTU6MDE6YjA6MzQ6CiAgICAgICAgIDUzOjY5OmRjOjIwOmYyOmY4OmJjOjEyOjJiOjNkOjkyOjM3OjdhOjY3OjZiOmJkOjkzOmZlOgogICAgICAgICA1NTpiMTo5YTo4Yjo5NTpiOTpjMDpkYzpiOToxMTo1MDo5ODoyNjo0MzpkOTpkZTo5ZTo2NzoKICAgICAgICAgZTE6NWE6MmI6YTI6ZmU6YWY6ZDE6ODY6NTQ6N2Y6YzE6NjE6Y2E6ZWQ6NjY6N2Y6YWY6ODQ6CiAgICAgICAgIGFiOjAyOmY5OjBhOmUyOmJkOjFhOjQ1OjgzOmU3OjM1Ojc4OjNkOjAzOmRkOjY4OjkyOjhlOgogICAgICAgICA2YTpkODpjZDoyYToxMzplYzphOTowMjo5OTo1Yzo3ZDplZDowMzo2Mzo5Mzo2MDo1ZTpiYToKICAgICAgICAgNDg6ODM6Zjc6ODA6YzA6YzQ6ZDU6YjM6NjI6NGE6MmM6Njc6NTE6YzA6MmM6MDE6NmU6OWM6CiAgICAgICAgIDNkOmExOjQ2OjcwOjZmOmUwOjIxOmYxOjE5OjE1OjJiOmZmOjQwOjNmOjk4OjdlOjMwOjI3OgogICAgICAgICAxYzplZTo5ZDo3ZQotLS0tLUJFR0lOIENFUlRJRklDQVRFLS0tLS0KTUlJRFl6Q0NBa3VnQXdJQkFnSVJBS3FUc1lDcnV1eWVnL2xwbFNUZmxta3dEUVlKS29aSWh2Y05BUUVMQlFBdwpGVEVUTUJFR0ExVUVBd3dLY21Gd2FHOWxjM1JsY2pBZUZ3MHlNakF6TWpjeE9UUXpNVFJhRncweU5EQTJNamt4Ck9UUXpNVFJhTUJVeEV6QVJCZ05WQkFNTUNuSmhjR2h2WlhOMFpYSXdnZ0VpTUEwR0NTcUdTSWIzRFFFQkFRVUEKQTRJQkR3QXdnZ0VLQW9JQkFRREc3OVlhUWtKdWtiajF2eVVsMkthTGcvdHRnN1lPYzQ4S01wL0c0dkdHbEJPUwo2MEUxaGIxTjF3ZU9tOHdzMG1lZHlWT0xpTTRST2RqZWNxR29nREQ1dXJsMXhhSWJ2aUI4WDZMUHQ2Sm9nN01SCjZDVnpZeWFudU1QTnlPNDJyNDZQRHBRQklQOE9RY3Z0KzNRRkxVU3BGaDFJMUtSMVQrOUVPcUR3WHA2YkdhNkIKTTlEUi9FR2hXWjl3SGFwekpiVzJkR05YenpYbnZpWlRGTlhucy9vdHpKVWpTTm5WTk9JSEd5Y2p2cmozdGRsdwpYU21GZFN2NlF2VmlXVDhJZGtkbTl4eThOMUt3ZUNjMGNYNjJQUVROSXpLbUdtZWtpQ29LOGhLbGVOdTl5VjRSCmhrRFJRZS9jYTQ5Vy9WTGFUN1h3T3Y3SEVIN0VlV0ZlMjUrR3lmdTNBZ01CQUFHamdhMHdnYW93Q1FZRFZSMFQKQkFJd0FEQWRCZ05WSFE0RUZnUVVCVC9aSWZnYXMwT053a0J5bndGSUYwRjN6amt3UlFZRFZSMGpCRDR3UElBVQpOYitwUFY4ek9Bc0dmTXJzU0h5K2RuTysyLzZoR2FRWE1CVXhFekFSQmdOVkJBTU1DbkpoY0dodlpYTjBaWEtDCkNRQ1BGL1VxaXJUUWFUQVRCZ05WSFNVRUREQUtCZ2dyQmdFRkJRY0RBVEFMQmdOVkhROEVCQU1DQmFBd0ZRWUQKVlIwUkJBNHdESUlLY21Gd2FHOWxjM1JsY2pBTkJna3Foa2lHOXcwQkFRc0ZBQU9DQVFFQVdENFIvWnp0RUwxcwpXcDkyajVjS3BqaUNHdkMrUytnUTJENnFyaURMd3labDU3Zkh4MkVleHVMSytGV08yQlk0cjMrdGNsTWNhakpoClB0TTZXMWlWUmRvTjZQUkQ3Mi84R05FSUNXN1pUOWVjNXBzRDUzT05FVHFTc0RySnRHTDBxTEdnUTlQb0w2MmIKankvUDRPYkJIQWQ2bjdOU1hqUHVJV2FsQWJBMFUybmNJUEw0dkJJclBaSTNlbWRydlpQK1ZiR2FpNVc1d055NQpFVkNZSmtQWjNwNW40Vm9yb3Y2djBZWlVmOEZoeXUxbWY2K0Vxd0w1Q3VLOUdrV0Q1elY0UFFQZGFKS09hdGpOCktoUHNxUUtaWEgzdEEyT1RZRjY2U0lQM2dNREUxYk5pU2l4blVjQXNBVzZjUGFGR2NHL2dJZkVaRlN2L1FEK1kKZmpBbkhPNmRmZz09Ci0tLS0tRU5EIENFUlRJRklDQVRFLS0tLS0K","privatekey":"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","certificatechain":"LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSURNakNDQWhxZ0F3SUJBZ0lKQUk4WDlTcUt0TkJwTUEwR0NTcUdTSWIzRFFFQkN3VUFNQlV4RXpBUkJnTlYKQkFNTUNuSmhjR2h2WlhOMFpYSXdIaGNOTWpJd016STNNVGswTXpBMVdoY05Nekl3TXpJME1UazBNekExV2pBVgpNUk13RVFZRFZRUUREQXB5WVhCb2IyVnpkR1Z5TUlJQklqQU5CZ2txaGtpRzl3MEJBUUVGQUFPQ0FROEFNSUlCCkNnS0NBUUVBdUlqRXJzc0hHSFR3TmNFbjhVTmlKQjErQ0lzL2Q2aklVaXRjUlFJcEhseVJPYzMxaDNyOGlkV0oKK2pGNkFSSndXQThIcmRKYTVCTFhYK3BMWWtMblQ1V2xBVjZkNi9FT2xoUDlCM2tyNHE2ODB0TFhUM3J3UitOdAo0ZTZ0MnUzbjFIS0tsMGM0U25xRGY2b1NjRzE5SGh5OWcvbmp6eFpLVXhZd21tWDRZZXdsSnZNSXZ0VnA5M2JFClQ1MjdJdk5lcFN4MXBBTmhtLzVTRW1zQ3MwQ2pENmZZOXNrcWUra3piZE1TOFhNZlZQYkVXUzdjcG9lZERpSFEKdTVRQVhjSmxnRUVCTjMvbG5JZEpxQ0xQOEFTV2hWd3puSmNEemc5UEcrTlZ4S1A1MHV0bDdROHdsd0Z0R2d4UAp5REhvamNsbVBtQ291UmdHb2RrMnJBQ0lYME9PTFFJREFRQUJvNEdFTUlHQk1CMEdBMVVkRGdRV0JCUTF2Nms5Clh6TTRDd1o4eXV4SWZMNTJjNzdiL2pCRkJnTlZIU01FUGpBOGdCUTF2Nms5WHpNNEN3Wjh5dXhJZkw1MmM3N2IKL3FFWnBCY3dGVEVUTUJFR0ExVUVBd3dLY21Gd2FHOWxjM1JsY29JSkFJOFg5U3FLdE5CcE1Bd0dBMVVkRXdRRgpNQU1CQWY4d0N3WURWUjBQQkFRREFnRUdNQTBHQ1NxR1NJYjNEUUVCQ3dVQUE0SUJBUUN6YXU1QlNnSituZy92Cnd2SHVDTnEyZWg5c1M1M3pmVUlQeTZqTUZrZHprelVZTmI1WjFRK1hjb21GbU9xOVVmaWcxN2dZdUR3WC9nMlMKVklDMVJDdWxwVTNORnNLOEhrSDdjdVFPOGNjSnlWc3JtUndPSFhabmtwTnBoYXI4RFQvSjU5d3FNU09ZZUJQYgpuQU41T0piaUF0NlRBNmRsUXJidkFvWG04dXdHMjFSU1N1VHQ5UElsY3NGallQazhiQWJ0dXdldEVnYjVuNkhoClhhczA1S0dteENmZDZxNHAxYUxITkVpNTVSejg0bEVsVHVNZlA0ZEwyZjIzUnFncmpEQmNDRmEwN1owZHJNdjcKbERYNEovaVpXY08zWXJJWXppcVg5M015UzNSUCtrYXAvV0dIYlZDcWtpZ2lTODZwQkY1NDh3OWxXQ0xJai9kTgozRTI2V24zNgotLS0tLUVORCBDRVJUSUZJQ0FURS0tLS0tCg=="}}`
// yeah the string is long lol
var body ResponseBody
if err := json.Unmarshal([]byte(mystring), &body); err != nil {
fmt.Println(fmt.Errorf("failed unmarshaling response | %s", err.Error()))
}
fmt.Println(body.Error.ErrorMessage)
certChain, err := base64.StdEncoding.DecodeString(mystring)
if err != nil {
fmt.Println(err.Error())
}
fmt.Println(certChain)
}
type PkiGenerationInput struct {
TeacherUsername string `json:"teacherusername"`
}
type Response struct {
Headers ResponseHeaders `json:"headers"`
Body ResponseBody `json:"body"`
}
type ResponseHeaders struct {
ContentType string `json:"Content-Type"`
}
type ResponseBody struct {
PkiData ParsablePkiData `json:"pkidata"`
Error struct {
ErrorMessage string `json:"errormessage"`
ErrorType string `json:"errortype"`
} `json:"error"`
}
type ParsablePkiData struct {
Certificate string `json:"certificate"`
PrivateKey string `json:"privatekey"`
CertificateChain string `json:"certificatechain"`
}
Here is the output
errormessagetest
illegal base64 data at input byte 0
[]
the fact I can read the errormessagetest shows that the unmarshalling kinda works, so that's weird.
I checked for any unexported fields but we can clearly see they are all capitalized. I also reduced the string size "just to see" and it didn't change anything.
Answer to synthetize all of the comments :
First of all, my "dumb mistake" was because I tried to decode the wrong variable :
// mystring needs to be replaced by body.PkiData.Certificate
base64.StdEncoding.DecodeString(mystring)
But the research led us to discover that the json.Unmarshal() function decodes base64 by itself when the result type matches what the declared type. Given the fact the encoded data was a []byte, I just replaced the string type by a []byte in the struct.
That allows to create a much more simple version of the previous code :
type ResponseBody struct {
PkiData PkiData `json:"pkidata"`
}
type PkiData struct {
Certificate []byte
PrivateKey []byte
CertificateChain []byte
}
var body ResponseBody
if err := json.Unmarshal(rawResp.Payload, &body); err != nil {
return PkiData{}, fmt.Errorf("failed unmarshaling response | %s", err.Error())
}

Processing API in Golang Using Query?

I am trying to process a song using API.I have tried using a specific URL in http.get and further unmarshalling the data but the only element returned in the console is {}. Any help to send me in the right direction is appreciated.
Edit: here is some code. I have this in my main file.
var data [2]Data
if err != nil {
log.Fatal(err)
}
defer response.Body.Close()
if response.StatusCode != 200 {
log.Fatal("Didn't get 200")
}
rawData, err := ioutil.ReadAll(response.Body)
if err != nil {
log.Fatal(err)
}
json.Unmarshal(rawData, &data)
fmt.Println(data[0])
I have a struct created in a separate file for JSON tags/keys.
type Data struct {
SongID string `json:id`
Name string `json:name`
}
type data struct {
Error bool `json:"error"`
Response struct {
Results []struct {
ID int `json:"id"`
Name string `json:"name"`
} `json:"results"`
} `json:"response"`
}
This should be the data structure.
Use curl to request
curl https://searchly.asuarez.dev/api/v1/song/search?query=hello
use https://mholt.github.io/json-to-go/ to convert the JSON response to Golang struct.

How do I capitalize all keys in a JSON array?

I'm reading a file.json into memory. It's an array of objects, sample:
[
{"id":123123,"language":"ja-JP","location":"Osaka"}
,{"id":33332,"language":"ja-JP","location":"Tokyo"}
,{"id":31231313,"language":"ja-JP","location":"Kobe"}
]
I want to manipulate certain keys in this JSON file, so that they start with uppercase. Meaning
"language" becomes "Language" each time it's found. What I've done so far is to make a struct representing each object, as such:
type sampleStruct struct {
ID int `json:"id"`
Language string `json:"Language"`
Location string `json:"Location"`
}
Here, I define the capitalization. Meaning, id shouldn't be capitalized, but location and language should.
Rest of the code is as such:
func main() {
if len(os.Args) < 2 {
fmt.Println("Missing filename parameter.")
return
}
translationfile, err := ioutil.ReadFile(os.Args[1])
fileIsValid := isValidJSON(string(translationfile))
if !fileIsValid {
fmt.Println("Invalid JSON format for: ", os.Args[1])
return
}
if err != nil {
fmt.Println("Can't read file: ", os.Args[1])
panic(err)
}
}
func isValidJSON(str string) bool {
var js json.RawMessage
return json.Unmarshal([]byte(str), &js) == nil
}
// I'm unsure how to iterate through the JSON objects and only uppercase the objects matched in my struct here.
func upperCaseSpecificKeys()
// ...
Desired output, assuming the struct represents the whole data object, transform each key as desired:
[
{"id":123123,"Language":"ja-JP","Location":"Osaka"}
,{"id":33332,"Language":"ja-JP","Location":"Tokyo"}
,{"id":31231313,"Language":"ja-JP","Location":"Kobe"}
]
The documentation on json.Unmarshal says (with added emphasis):
To unmarshal JSON into a struct, Unmarshal matches incoming object
keys to the keys used by Marshal (either the struct field name or its
tag), preferring an exact match but also accepting a case-insensitive
match
See example here: https://play.golang.org/p/1vv8PaQUOfg
One way is to implement custom marshal method, although not very flexible:
type upStruct struct {
ID int `json:"id"`
Language string
Location string
}
type myStruct struct {
ID int `json:"id"`
Language string `json:"language"`
Location string `json:"location"`
}
func (m myStruct) MarshalJSON() ([]byte, error) {
return json.Marshal(upStruct(m))
}
....
func main() {
var mySArr []myStruct
// 1. Unmarshal the input
err := json.Unmarshal([]byte(myJson), &mySArr)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Input: \n%+v\n", mySArr)
// 2. Then, marshal it using our custom marshal method
val, err := json.Marshal(mySArr)
if err != nil {
log.Fatal(err)
}
fmt.Printf("Output: \n%v\n", string(val))
}
Link to working code: https://play.golang.org/p/T4twqPc34k0
Thanks to mkopriva

Parsing dynamic json in go

I am trying to parse the following json structure, where the fields marked with "val1" and "val2" are constantly changing, so I cannot use a predefined struct. How could I parse this json in a way to be able to loop through every single "val"? Thank you!
{"result":true,"info":{"funds":{"borrow":{"val1":"0","val2":"0"},"free":{"val1":"0","val2":"0"},"freezed":{"val1":"0","val2":"0"}}}}
By unmarshalling into the following struct I can loop through the desired fields.
type Fields struct {
Result bool `json:"result"`
Info struct {
Funds struct {
Borrow, Free, Freezed map[string]interface{}
} `json:"funds"`
} `json:"info"`
}
package main
import (
"fmt"
"encoding/json"
)
type Root struct {
Result bool `json:"result"`
Info Info `json:"info"`
}
type Info struct {
Funds struct {
Borrow, Free, Freezed map[string]interface{}
} `json:"funds"`
}
func main() {
var rootObject Root
jsonContent := " {\"result\":true,\"info\":{\"funds\":{\"borrow\":{\"val1\":\"0\",\"val2\":\"0\"},\"free\":{\"val1\":\"0\",\"val2\":\"0\"},\"freezed\":{\"val1\":\"0\",\"val2\":\"0\"}}}}"
if err := json.Unmarshal([]byte(jsonContent), &rootObject); err != nil {
panic(err)
}
fmt.Println(rootObject)
}

golang json unmarshal part of map[string]interface{}

I have the following code to try to Unmarshal this json file, however the line json.Unmarshal([]byte(msg["restaurant"]), &restaurant) always gives an error. How can I make Unmarshal ignore the "restaurant" or pass only the "restaurant" data to the Unmarshal function?
Thanks!
{
"restaurant": {
"name": "Tickets",
"owner": {
"name": "Ferran"
}
}
}
file, e := ioutil.ReadFile("./rest_read.json")
if e != nil {
fmt.Println("file error")
os.Exit(1)
}
var data interface{}
json.Unmarshal(file, &data)
msg := data.(map[string]interface{})
log.Println(msg)
log.Println(msg["restaurant"])
log.Println(reflect.TypeOf(msg["restaurant"]))
var restaurant Restaurant
json.Unmarshal([]byte(msg["restaurant"]), &restaurant)
log.Println("RName: ", restaurant.Name)
log.Println("Name: ", restaurant.Owner.Name)
It is possible to do generic unmarshalling ala gson by decoding into an interface and then extracting a top level map from the result, e.g:
var msgMapTemplate interface{}
err := json.Unmarshal([]byte(t.ResponseBody), &msgMapTemplate)
t.AssertEqual(err, nil)
msgMap := msgMapTemplate.(map[string]interface{})
See "decoding arbitrary data" in http://blog.golang.org/json-and-go for more into.
I would propose to construct a proper model for your data. This will enable you to cleanly unmarshal your data into a Go struct.
package main
import (
"encoding/json"
"fmt"
)
type Restaurant struct {
Restaurant RestaurantData `json:"restaurant"`
}
type RestaurantData struct {
Name string `json:"name"`
Owner Owner `json:"owner"`
}
type Owner struct {
Name string `json:"name"`
}
func main() {
data := `{"restaurant":{"name":"Tickets","owner":{"name":"Ferran"}}}`
r := Restaurant{}
json.Unmarshal([]byte(data), &r)
fmt.Printf("%+v", r)
}
Unmarshalling occurs recursively, so msg["restaurant"] is no longer a json string - it is another map[string]interface{}. If you want to unmarshall directly into a Restaurant object, you will have to provide a simple wrapper object with a Restaurant member and unmarshall into that.