json unmarshal generic interface{}

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")
		}
	}
}

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.