golang json and slices of interface

Question

I am having trouble iterating over slices of interfaces that contain slices of interfaces.

This problem has arisen through attempting to work with an API call which retu

Answer 1

Well, you can't cast []interface{} to map[string]interface{}. Since it's a slice, you can iterate over its elements (note that bb is b already cast to the appropriate type and you don't need to cast b again):

    case []interface{}:
        fmt.Println(" is []interface ", bb)
        for _, val := range bb {
            // do something with val
        }
    default:
    ...

Why do you have to deal with something that you don't know? Is it possible that you reconsider your architecture and work with known type(s)? have you seen the example of delaying unmarshaling using json.RawMessage? Or maybe try implementing the Unmarshaler interface?

Answer 2

You can add a switch case which is checking the type of interface for slice of interfaces and then run the same function as recursive until whole json is parsed.

output := make(map[string]interface{})
err = json.Unmarshal(body, &output)

fmt.Println(err)
identify(output)

return err
}

func identify(output map[string]interface{}) {
    fmt.Printf("%T", output)
    for a, b := range output {
        switch bb := b.(type) {
        case string:
            fmt.Println("This is a string")
        case float64:
            fmt.Println("this is a float")
        case []interface{}:
        // Access the values in the JSON object and place them in an Item
        for _, itemValue := range jsonObj {
            fmt.Printf("%v is an interface\n", itemValue)
            identify(itemValue.(map[string]interface{}))
        }
        default:
            return
        }
    }
}

There can be deep nested json. We just needs to create options for each case until json is completely parsed.