How to unmarshal a JSON field which is either an struct or array of stuct?

Use case

I have an API in which I receive the user input as an object or array of objects. Like this:

JSON without Array

{
  "sign": {
    "page_no": 1,
    "x_coord": 100,
    "y_coord": 300
  }
}

JSON with Array

{
  "sign": [
    {
      "page_no": 1,
      "x_coord": 100,
      "y_coord": 300
    },
    {
      "page_no": 2,
      "x_coord": 200,
      "y_coord": 400
    }
  ]
}

Struct to Unmarshal to

type Document struct {
  Sign []Sign `json:"sign"` // or just Sign
}

type Sign struct {
  PageNo int `json:"page_no"`
  XCoord int `json:"x_coord"`
  YCoord int `json:"y_coord"`
}

I cannot make the Sign field on the Document as an array for all user inputs due to legacy reasons so It needs to be both array of Sign as well as just Sign.

How to unmarshal it so that it can handle both of the JSON requests below?

I Know That...

We can use map[string]interface{} instead of the struct but that will lead to too many key assertions which you don't have to do when I am using struct because I can leverage the zero values for them.

Also, this answer on Stackoverflow seems okay but I wanted to know is a there better way to do it?

You can do this without interface{} (or type assertions) at all, by implementing a custom unmarshaler. I would implement the unmarshaler by peeking inside the JSON, and checking to see if it starts with a square bracket or curly brace... skipping whitespace.

See the json.Unmarshaler interface in the docs.

type Document struct {
	Sign SignList
}

type SignList []Sign

func (l *SignList) UnmarshalJSON(d []byte) error {
	for _, b := range d {
		switch b {
        // These are the only valid whitespace in a JSON object.
		case ' ', '\n', '\r', '\t':
		case '[':
			return json.Unmarshal(d, (*[]Sign)(l))
		case '{':
			var obj Sign
			if err := json.Unmarshal(d, &obj); err != nil {
				return err
			}
			*l = []Sign{obj}
			return nil
		default:
			return errors.New("sign must be object or list")
		}
	}
	return errors.New("sign must be object or list")
}

This may seem a little bit clumsy. Oh well. There are alternative JSON unmarshaling libraries for Go besides encoding/json. Try out an alternative JSON library if you like. This code works with just encoding/json.

Here is how you can test that this code works:

package main

import (
	"fmt"
	"encoding/json"
	"errors"
)

type Sign struct {
	X int
}

func main() {
	cases := []string {
		`{"Sign": {"X": 1}}`,
		`{"Sign": [{"X": 1}, {"X": 2}]}`,
	}
	for _, c := range cases {
		var doc Document
		if err := json.Unmarshal([]byte(c), &doc); err != nil {
			fmt.Println("Error:", err)
			continue
		}
		fmt.Printf("Document: %+v\n", &doc)
	}
}

This prints:

Document: &{Sign:[{X:1}]}
Document: &{Sign:[{X:1} {X:2}]}

Create a slice type with a custom json unmarshaler method. Then in that unmarshaler, you can detect which type of input you have, and behave accordingly. This approach is detailed further in my video Advanced JSON handling in Go.

type Signs []Sign

func (s *Signs) UnmarshalJSON(d []byte) error {
    if d[0] == '{' {
        // We know it's a single object
        var v Sign
        err := json.Unmarshal(d, &v)
        *s = Signs{v}
        return err
    }
    // Otherwise it's an array
    var v []Sign
    err := json.Unmarshal(d, &v)
    *s = Signs(v)
    return err
}

Implement a type to test which can validate your data is of, and use that to as a check.

For example:

package main

type SignTest struct {
	Sign map[string]interface{} `json:"sign"`
}

func main() {
	s := `{
  "sign": [
    {
      "page_no": 1,
      "x_coord": 100,
      "y_coord": 300
    },
    {
      "page_no": 2,
      "x_coord": 200,
      "y_coord": 400
    }
  ]
}`

	err := json.Unmarshal([]byte(s), &SignTest{})

	if err != nil {
		fmt.Println("Document Type")
	} else {
		fmt.Println("Sign Type")
	}
}

Prints Document Type, while

package main


type SignTest struct {
	Sign map[string]interface{} `json:"sign"`
}

func main() {
	s := `{
  "sign": {
    "page_no": 1,
    "x_coord": 100,
    "y_coord": 300
  }
}`

	err := json.Unmarshal([]byte(s), &SignTest{})

	if err != nil {
		fmt.Println("Document Type")
	} else {
		fmt.Println("Sign Type")
	}
}

Prints Sign Type.

But here might be an error while unmarshalling the object other than the sign is an array or not., If you want even more safety, check the error message of the error that is should be as expected before assuming it as Document.