Unmarshaling array of objects in Go

in GO, I've tried to produce the following json :

[["my",257.14,257.24],["txt", 121.11, 65.555]]

from a struct that's undergo unmarshaling - and i'm failing to do so.

Here is what I tried:

x := []MyStruct{{Zero: map[int]string{0: "str"}, One: map[int]float32{1: 5.6}, Two: map[int]float32{1: 5.88}}}

where MyStruct is :

type Timestamp struct {
  Zero		map[int]string		`json:"0"`
  One		map[int]float32		`json:"1"`
  Two		map[int]float32		`json:"2"`
}

this produces the wrong json structure:

"myStruct":[{"0":{"0":"has"},"1":{"1":5.6},"2":{"1":5.88}}]

tried this as well

any clue in the right direction will be highly appreciated.

Maybe this is your expected. It's possible to implement custom MarshalJSON/UnmarshalJSON.

package main
import (
"encoding/json"
"errors"
"fmt"
"log"
)
type Timestamp struct {
Zero []string
One  []float32
Two  []float32
}
func (t *Timestamp) UnmarshalJSON(b []byte) error {
var arr [][3]interface{}
err := json.Unmarshal(b, &arr)
if err != nil {
return nil
}
t.Zero = nil
t.One = nil
t.Two = nil
for _, v := range arr {
if len(v) != 3 {
return errors.New("invalid json")
}
if s, ok := v[0].(string); ok {
t.Zero = append(t.Zero, s)
}
if f, ok := v[1].(float64); ok {
t.One = append(t.One, float32(f))
}
if f, ok := v[2].(float64); ok {
t.Two = append(t.Two, float32(f))
}
}
return nil
}
func (t *Timestamp) MarshalJSON() ([]byte, error) {
var arr [][3]interface{}
var max int
if max < len(t.Zero) {
max = len(t.Zero)
}
if max < len(t.One) {
max = len(t.One)
}
if max < len(t.Two) {
max = len(t.Two)
}
for i := 0; i < max; i++ {
var v [3]interface{}
if i < len(t.Zero) {
v[0] = t.Zero[i]
}
if i < len(t.One) {
v[1] = t.One[i]
}
if i < len(t.Two) {
v[2] = t.Two[i]
}
arr = append(arr, v)
}
return json.Marshal(arr)
}
const j = `[["my",257.14,257.24],["txt", 121.11, 65.555]]`
func main() {
var ts Timestamp
err := json.Unmarshal([]byte(j), &ts)
if err != nil {
log.Fatal(err)
}
b, err := json.Marshal(&ts)
if err != nil {
log.Fatal(err)
}
fmt.Println(string(b))
}

https://play.golang.org/p/WtVEja1JDY

The problem you are having is you're trying to unmarshal a map, and a map will correlate to a JSON object. Your desired output is a list, so you need to unmarshal an array or a slice to get a list as your values.

Try making an adapter.

Small example:

type Object struct {
Base   float32 
Radius float32 
Height float32 
X      float32 
Y      float32 
}
func (obj *Object) ToCircle() *Circle {
return &Circle{
Radius: obj.Radius,
X:      obj.X,
Y:      obj.Y,
}
}
func (obj *Object) ToRectangle() *Rectangle {
return &Rectangle{
Base:   obj.Base,
Height: obj.Height,
X:      obj.X,
Y:      obj.Y,
}
}

In the example above, Object is converted to a Rectangle or a Circle using the ToRectangle() and ToCircle() adapters, respectively. In your case, you need to convert Timestamp to a []interface{}. Then you can unmarshal and you'll just get a list of whatever values are in that slice, which is your desired output in this case.

For intsance, the signature if your adapter could look like this:

func (t *Timestamp) ToFoo() []interface{} {
var ret []interface{}
// Do some stuff to take values of 't' and append to 'ret'
return ret
}
func main() {
var result []interface{}
json.Unmarshal(t.ToFoo(), &result)
// ...
}

I'll leave the implementation details for you.