golang json unstructured data - arrays

Question

I have a json (unstructured) and wants to retrieve each and every key from the json data
Then loop through the keys and value. If the value is of type json (nested) or array then keep continuing.
I have found an example of structured json parsing but cannot get this.
Checked this code but could not get the complete one
err := json.Unmarshal([]byte(input), &customers)
Sample json:
{
"components": [
{
"key": "d1",
"components": [
{
"key": "custname",
"value": "Abraham",
"input": true,
"tableView": true
},
{
"key": "type",
"type": "radio",
"label": "Fisrt",
"values": [
{
"label": "Sole",
"value": "sole",
"shortcut": ""
},
{
"label": "Bata",
"value": "Bata",
"shortcut": ""
}
],
"validate": {
"required": true
},
"tableView": false
},
{
"key": "registeredField",
"value": "reg 111",
"input": true,
},
{
"key": "dirc",
"value": "abraham",
},
{
"key": "gst",
"value": "textfield",
"useLocaleSettings": false
},
{
"key": "pan",
"value": "AAAAA0000",
"useLocaleSettings": false
}
],
"collapsible": false
}
]
}
Expected output:
Key: custname Value: Abraham
Key: type Value: {
"label": "Sole",
"value": "sole",
"shortcut": ""
}, {
"label": "Bata",
"value": "Bata",
"shortcut": ""
}
Key: registeredField Value: reg 111

Answer 1

So you have an object with a key components, that is a slice of components. Each of these components can have a number of keys. First thing to do is to take stock of all possible fields a component can have and define a type with said fields:
type Validation struct {
Required bool `json:"required"`
}
type Value struct {
Label string `json:"label"`
Value string `json:"value"`
Shortcut string `json:"shortcut"`
}
type Data struct {
Components []Data `json:"components,omitempty"`
Collapsable bool `json:"collapsable"`
Input bool `json:"input"`
Key string `json:"key"`
TableView bool `json:"tableView"`
Type string `json:"type"`
Value string `json:"value"`
UseLocaleSettings bool `json:"useLocaleSettings"`
Values []Value `json:"values,omitempty"`
Validate *Validation `json:"validate,omitempty"`
}
Now you simply take the input and unmarshal it into the Data type:
data := Data{}
if err := json.Unmarshal([]byte(input), &data); err != nil {
// handle error
fmt.Printf("Oops, something went wrong: %+v", err)
return
}
At this point, we have all the data in a struct, so we can start printing it all out. First thing we notice is how Data basically contains a slice of Data types. A recursive function to print it all out would make sense:
func PrintComponents(data []Data) {
for _, c := range data {
if len(c.Components) > 0 {
PrintComponents(c.Components) // recursive
continue // skip value of this component, remove this line if needed
}
val := c.Value // assign string value
if len(c.Values) > 0 {
// this component has a slice of values, not a single value
vals, err := json.MarshalIndent(c.Values, "", " ") // marshal with indent of 4 spaces, no prefix
if err != nil {
fmt.Printf("Oops, looks like we couldn't format something: %+v\n", err)
return // handle this
}
val = string(vals) // marshalled values as string
}
fmt.Printf("Key: %s Value: %s\n", c.Key, val) // print output
}
}
You could alter this function a bit to pass in an indent parameter for each level of recursion, so you can print out the components in indented blocks:
func PrintComponents(data []Data, indent string) {
for _, c := range data {
if len(c.Components) > 0 {
// print the key for this block of components
fmt.Printf("Component block: %s\n", c.Key)
PrintComponents(data, indent + " ") // current indent + 4 spaces
continue // we're done with this component
}
val := c.Value
if len(c.Values) > 0 {
vals, _ := json.MarshalIndent(c.Values, indent, " ") // pass in indent level here, and DON'T ignore the error, that's just for brevity
val = string(vals)
}
fmt.Printf("%sKey: %s Value: %s\n", indent, c.Key, val) // pass in indent
}
}
Putting it all together, we get this:
func main() {
data := Data{}
if err := json.Unmarshal(input, &data); err != nil {
fmt.Println(err.Error())
return
}
fmt.Println("Printing with simple recursive function")
// print all components, these could be nested, so let's use a recursive function
PrintComponents(data.Components)
fmt.Println("\n\nPrinting with indented recursion:")
PrintComponentsIndent(data.Components, "") // start with indent of 0
}
func PrintComponents(data []Data) {
for _, c := range data {
if len(c.Components) > 0 {
PrintComponents(c.Components) // recursive
continue // skip value of this component, remove this line if needed
}
val := c.Value // assign string value
if len(c.Values) > 0 {
// this component has a slice of values, not a single value
vals, err := json.MarshalIndent(c.Values, "", " ") // marshal with indent of 4 spaces, no prefix
if err != nil {
fmt.Printf("Oops, looks like we couldn't format something: %+v\n", err)
return // handle this
}
val = string(vals) // marshalled values as string
}
fmt.Printf("Key: %s Value: %s\n", c.Key, val) // print output
}
}
func PrintComponentsIndent(data []Data, indent string) {
for _, c := range data {
if len(c.Components) > 0 {
fmt.Printf("%sComponent block: %s\n", indent, c.Key)
PrintComponentsIndent(c.Components, indent + " ")
continue
}
val := c.Value
if len(c.Values) > 0 {
// this component has a slice of values, not a single value
vals, _ := json.MarshalIndent(c.Values, indent, " ")
val = string(vals) // marshalled values as string
}
fmt.Printf("%sKey: %s Value: %s\n", indent, c.Key, val) // print output
}
}
Which outputs:
Printing with simple recursive function
Key: custname Value: Abraham
Key: type Value: [
{
"label": "Sole",
"value": "sole",
"shortcut": ""
},
{
"label": "Bata",
"value": "Bata",
"shortcut": ""
}
]
Key: registeredField Value: reg 111
Key: dirc Value: abraham
Key: gst Value: textfield
Key: pan Value: AAAAA0000
Printing with indented recursion:
Component block: d1
Key: custname Value: Abraham
Key: type Value: [
{
"label": "Sole",
"value": "sole",
"shortcut": ""
},
{
"label": "Bata",
"value": "Bata",
"shortcut": ""
}
]
Key: registeredField Value: reg 111
Key: dirc Value: abraham
Key: gst Value: textfield
Key: pan Value: AAAAA0000
Your desired output doesn't include the square brackets for the values slice. Well, that's a really easy thing to get rid of. The square brackets are always the first and last characters of the string, and json.Marshal returns a byte slice ([]byte). Chopping off the first and last characters is as easy as:
val = string(vals[1:len(vals)-2])
Taking a sub-slice of the byte slice returned by json.Marshal, starting at offset 1 (cutting of offset 0, which is [), and keeping everything until the next to last character (offset len(vals)-2). For the indented example, that will leave you with a blank line, containing an unknown number of spaces (indentation). You can trim the right-hand side of the string using the strings package:
// remove square brackets, trim trailing new-line and spaces
val = strings.TrimRight(string(vals[1:len(vals)-2]), "\n ")