Merging two different structs and marshalling them - Golang

Let's say I have the first struct as

type Person struct {
	Name string                 `json:"person_name"`
	Age  int                    `json:"person_age"`
	Data map[string]interface{} `json:"data"`
}

and I am trying to marshal an array of the above struct
Things work well till here and a sample response I receive is

[
   {
      "person_name":"name",
      "person_age":12,"data":{}
   },
   {
      "person_name":"name2",
      "person_age":12,"data":{}
   }
]

Now, I need to append another struct over here and the final response should like

[
   {
      "person_name":"name",
      "person_age":12,"data":{}
   },
   {
      "person_name":"name2",
      "person_age":12,"data":{}
   }, 
   {
      "newData":"value"
   }
]

So can someone help on this and how i can achieve this ?

I tried by creating an []interface{} and then iterating over person to append each data, but the issue in this approach is that it makes the Data as null if in case it's an empty string.
I would need it be an empty map only.

Let me prefix this by saying this looks to me very much like you might be dealing with an X-Y problem. I can't really think of many valid use-cases where one would end up with a defined data-type that has to somehow be marshalled alongside a completely different, potentially arbitrary/freeform data structure. It's possible, though, and this is how you could do it:

So you just want to append a completely different struct to the data-set, then marshal it and return the result as JSON? You'll need to create a new slice for that:

personData := []Person{} // person 1 and 2 here
more := map[string]string{ // or some other struct
    "newdata": "value",
}
allData := make([]any, 0, len(personData) + 1) // the +1 is for the more, set cap to however many objects you need to marshal
for _, p := range personData {
    allData = append(allData, p) // copy over to this slice, because []Person is not compatible with []any
}
allData = append(allData, more)
bJSON, err := json.Marshal(allData)
if err != nil {
    // handle
}
fmt.Println(string(bJSON))

Essentially, because you're trying to marshal a slice containing multiple different types, you have to add all objects to a slice of type any (short for interface{}) before marshalling it all in one go

Cleaner approaches

There are much, much cleaner approaches that allow you to unmarshal the data, too, assuming the different data-types involved are known beforehand. Consider using a wrapper type like so:

type Person struct {} // the one you have

type NewData {
   NewData string `json:"newdata"`
}

type MixedData struct {
    *Person
    *NewData
}

In this MixedData type, both Person and NewData are embedded, so MixedData will essentially act as a merged version of all embedded types (fields with the same name should be overridden at this level). With this type, you can marshal and unmarshal the JSON accordingly:

allData := []MixedData{
    {
        Person: &person1,
    },
    {
        Person: &person2,
    },
    {
        NewData: &newData,
    },
}

Similarly, when you have a JSON []byte input, you can unmarshal it same as you would any other type:

data := []MixedData{}
if err := json.Unmarshal(&data, in); err != nil {
    // handle
}
fmt.Printf("%#v\n", data) // it'll be there

It pays to add some functions/getters to the MixedData type, though:

func (m MixedData) IsPerson() bool { return m.Person != nil }

func (m MixedData) Person() *Person {
    if m.Person == nil {
        return nil
    }
    cpy := *m.Person // create a copy to avoid shared pointers
    return &cpy // return pointer to the copy
}

Do the same for all embedded types and this works like a charm.

As mentioned before, should your embedded types contain fields with the same name, then you should override them in the MixedData type. Say you have a Person and Address type, and both have an ID field:

type MixedData struct {
    ID  string `json:"id"`
    *Person
    *Address
}

This will set the ID value on the MixedData type, and all other (non-shared) fields on the corresponding embedded struct. You can then use the getters to set the ID where needed, or use a custom unmarshaller, but I'll leave that to you to implement