Unmarshal json array to struct

The other answers seem too complicated, here is another approach:

package main

import (
   "encoding/json"
   "fmt"
)

type myType struct {
   count int
   name string
   relation map[string]string
}

func (t *myType) UnmarshalJSON(b []byte) error {
   a := []interface{}{&t.count, &t.name, &t.relation}
   return json.Unmarshal(b, &a)
}

func main() {
   var t myType
   json.Unmarshal([]byte(`[1, "test", {"a": "b"}]`), &t)
   fmt.Printf("%+v\n", t)
}

https://eagain.net/articles/go-json-array-to-struct

You can use github.com/ugorji/go/codec, it can unmarshal array to a struct:

Encode a struct as an array, and decode struct from an array in the data stream

Although the library advertises "drop-in replacement for encoding/json" - it's only about the json: tag. So you have to use codec.Decoder instead of json.Unmarshal:

package main

import "fmt"
import "github.com/ugorji/go/codec"

type MyType struct {
    Count    int
    Name     string
    Relation map[string]string
}

func main() {
    x := &MyType{}
    data := []byte(`[1,"test",{"a":"b"}]`)
    codec.NewDecoderBytes(data, new(codec.JsonHandle)).Decode(x)
    fmt.Println(x)
}

That is a tuple, and it's perfectly fine to unmarshal tuple into a structure, except that encoding/json doesn't support that.

However we can use the following helper function, which iterates over the fields of the structure and unmarshals them:

// UnmarshalJSONTuple unmarshals JSON list (tuple) into a struct.
func UnmarshalJSONTuple(text []byte, obj interface{}) (err error) {
    var list []json.RawMessage
    err = json.Unmarshal(text, &list)
    if err != nil {
        return
    }

    objValue := reflect.ValueOf(obj).Elem()
    if len(list) > objValue.Type().NumField() {
        return fmt.Errorf("tuple has too many fields (%v) for %v",
            len(list), objValue.Type().Name())
    }

    for i, elemText := range list {
        err = json.Unmarshal(elemText, objValue.Field(i).Addr().Interface())
        if err != nil {
            return
        }
    }
    return
}

So you only need to provide the UnmarshalJSON method:

func (this *MyType) UnmarshalJSON(text []byte) (err error) {
    return UnmarshalJSONTuple(text, this)
}

Here is the complete example: http://play.golang.org/p/QVA-1ynn15

since your json holds values of different types in an array it is not possible to parse this with go simply. If you have controll over how the json input is formatted, wrap the three values in {} to form an object, like so:

[
    {
        "Count": 1,
        "Name": "test",
        "Relation": { "a" : "b" }
     }
]

Then parsing into your struct should work.

If you have no controll over the json input. Parse it as []interface{} and then assign the values to your struct manually. Even though this might get tricky, depending on complexity of possible responses you'd like to support.

Please note, that this issue points to a core limitation of golangs json parsing method and that therefore - as far as I know - it can also not be solved by libraries.