json解组通用接口{}

Question

http://blog.golang.org/json-and-go

m := j.(map[string]interface{}) didn't work for me

panic: interface conversion: interface {} is []interface {}, not map[string]interface {}

So I end up with code like this to make it work? Don't think its the correct way of doing it :)

    var j interface{}
    err = json.Unmarshal(b, &j)
    if err != nil {
        log.Print(err.Error())
    }

    m := j.([]interface{}) //map[string]interface{}

    for k, v := range m {
        switch vv := v.(type) {
        case string:
            fmt.Println(k, "is string", vv)
        case int:
            fmt.Println(k, "is int", vv)
        case []interface{}:
            fmt.Println(k, "is an array:")
            for i, u := range vv {
                fmt.Println(i, u)
            }
        case map[string]interface{}:
            for k2, v2 := range v.(map[string]interface{}) {
                switch vv2 := v2.(type) {
                case string:
                    fmt.Println(k2, "is string", vv2)
                case int:
                    fmt.Println(k2, "is int", vv2)
                case []interface{}:
                    fmt.Println(k2, "is an array:")
                    for i2, u2 := range vv2 {
                        fmt.Println(i2, u2)
                    }
                default:
                    fmt.Println(k2, "is of a type I don't know how to handle")
                }
            }
        default:
            fmt.Println(k, "is of a type I don't know how to handle")
        }
    }

EDIT: My failed attempt to make it readable

    var j interface{}
    err = json.Unmarshal(b, &j)
    if err != nil {
        log.Print(err.Error())
    }
    write(j.([]interface{}))

func write(j []interface{}) {
    for k, v := range j {
        switch vv := v.(type) {
        case string:
            fmt.Println(k, "is string", vv)
        case int:
            fmt.Println(k, "is int", vv)
        case []interface{}:
            fmt.Println(k, "is an array:")
            for i, u := range vv {
                fmt.Println(i, u)
            }
        case map[string]interface{}:
            write(v.([]interface{}))
        default:
            fmt.Println(k, "is of a type I don't know how to handle")
        }
    }
}

EDIT2: Works but still ugly

    var j interface{}
    err = json.Unmarshal(b, &j)
    if err != nil {
        log.Print(err.Error())
    }
    write(j.([]interface{}))

func write(j []interface{}) {
    for k, v := range j {
        switch vv := v.(type) {
        case string:
            fmt.Println(k, "is string", vv)
        case int:
            fmt.Println(k, "is int", vv)
        case []interface{}:
            fmt.Println(k, "is an array:")
            for i, u := range vv {
                fmt.Println(i, u)
            }
        case map[string]interface{}:
            write2(v.(map[string]interface{}))
        default:
            fmt.Println(k, "is of a type I don't know how to handle")
        }
    }
}

func write2(j map[string]interface{}) {
    for k, v := range j {
        switch vv := v.(type) {
        case string:
            fmt.Println(k, "is string", vv)
        case int:
            fmt.Println(k, "is int", vv)
        case []interface{}:
            fmt.Println(k, "is an array:")
            for i, u := range vv {
                fmt.Println(i, u)
            }
        default:
            fmt.Println(k, "is of a type I don't know how to handle")
        }
    }
}

Answer 1

It seems as the root part of the JSON code is a JSON array (the ["item", "item", {"key": "value"}] notation). Although some JSON libraries don't like it, the "root" of the JSON blob can be an array and not an object (the {"key": "value"} notation).

In a production application, you should use the second value of type assertions to make sure it's the right type:

m, mOk := j.(map[string]interface{})
s, sOk := j.([]interface{})

if mOk {
    // Use Map
} else {
    // Use Slice
}

If you don't need to edit the data, Jason is a great library for Go.