Unmarshall into an interface type

I expected below code to print an object of type struct J, however it prints a map object of type map[string]interface{}. I can feel why it acts like that, however when I run, reflect.ValueOf(i).Kind(), it returns Struct, so it kinda gives me the impression that Unmarshal method should return type J instead of a map. Could anyone enlighten me ?

type J struct {
	Text string
}

func main() {
	j := J{}
	var i interface{} = j

	js := "{\"Text\": \"lala\"}"


	json.Unmarshal([]byte(js), &i)

    fmt.Printf("%#v", i)

}

The type you're passing into Unmarshal is not *J, you're passing in an *interface{}.

When the json package reflects what the type is of the pointer it received, it sees interface{}, so it then uses the default types of the package to unmarshal into, which are

bool, for JSON booleans
float64, for JSON numbers
string, for JSON strings
[]interface{}, for JSON arrays
map[string]interface{}, for JSON objects
nil for JSON null

There is almost never a reason to use a pointer to an interface. If you find yourself using a pointer to an interface, and you don't know exactly why, then it's probably a mistake. If you want to unmarshal into J, then pass that in directly. If you need to assign that to an intermediary interface, make sure you use a pointer to the original value, not a pointer to its interface.

http://play.golang.org/p/uJDFKfSIxN

j := J{}
var i interface{} = &j

js := "{\"Text\": \"lala\"}"

json.Unmarshal([]byte(js), i)

fmt.Printf("%#v", i)

This is expected behavior: instead of giving json.Unmarshal a pointer to a properly typed place in memory you give it a pointer to a place in memory with type interface{}. It can essentially store anything in there under the type the JSON defines, so it does just that.

See it like this:

1. Unmarshal gets a place to store the data v with type interface{}
2. Unmarshal detects a map encoded as JSON
3. Unmarshal sees that the target type is of type interface{}, creates a go map from it and stores it in v

If you would have given it a different type than interface{} the process would have looked like this:

1. Unmarshal gets a place to store the data v with type struct main.J
2. Unmarshal detects a map encoded as JSON
3. Unmarshal sees that the target type is struct main.J and begins to recursively fit the data to the type

The main point is, that the initial assignment

var i interface{} = j

is completely ignored by json.Unmarshal.