Golang interface to struct

I have a function that has a parameter with the type interface{}, something like:

func LoadTemplate(templateData interface{}) {

In my case, templateData is a struct, but each time it has a different structure. I used the type "interface{}" because it allows me to send all kind of data.

I'm using this templateData to send the data to the template:

err := tmpl.ExecuteTemplate(w, baseTemplateName, templateData)

But now I want to append some new data and I don't know how to do it because the "interface" type doesn't allow me to add/append anything.

I tried to convert the interface to a struct, but I don't know how to append data to a struct with an unknown structure.

If I use the following function I can see the interface's data:

templateData = appendAssetsToTemplateData(templateData)

func appendAssetsToTemplateData(t interface{}) interface{} {
	switch reflect.TypeOf(t).Kind() {
	case reflect.Struct:
		fmt.Println("struct")
		s := reflect.ValueOf(t)
		fmt.Println(s)
		
		//create a new struct based on current interface data
	}

	return t
}

Any idea how can I append a child to the initial interface parameter (templateData)? Or how can I transform it to a struct or something else in order to append the new child/data?

Adrian is correct. To take it a step further, you can only do anything with interfaces if you know the type that implements that interface. The empty interface, interface{} isn't really an "anything" value like is commonly misunderstood; it is just an interface that is immediately satisfied by all types.

Therefore, you can only get values from it or create a new "interface" with added values by knowing the type satisfying the empty interface before and after the addition.

The closest you can come to doing what you want, given the static typing, is by embedding the before type in the after type, so that everything can still be accessed at the root of the after type. The following illustrates this.

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

package main

import (
	"fmt"
)

type Before struct {
	m map[string]string
}

type After struct {
	Before
	s []string
}

func contrivedAfter(b interface{}) interface{} {
	return After{b.(Before), []string{"new value"}}
}

func main() {
	b := Before{map[string]string{"some": "value"}}
	a := contrivedAfter(b).(After)
	fmt.Println(a.m)
	fmt.Println(a.s)
}

Additionally, since the data you are passing to the template does not require you to specify the type, you could use an anonymous struct to accomplish something very similar.

https://play.golang.org/p/3KUfHULR84

package main

import (
	"fmt"
)

type Before struct {
	m map[string]string
}

func contrivedAfter(b interface{}) interface{} {
	return struct{
		Before
		s []string
	}{b.(Before), []string{"new value"}}
}

func main() {
	b := Before{map[string]string{"some": "value"}}
	a := contrivedAfter(b)
	fmt.Println(a)
}

You can't append data arbitrarily to a struct; they're statically typed. You can only assign values to the fields defined for that specific struct type. Your best bet is probably to use a map instead of structs for this.

Not recommended, but you can create structs dynamically using the reflect package.

Here is an example:

package main

import (
	"encoding/json"
	"os"
	"reflect"
)

type S struct {
	Name string
}

type D struct {
	Pants bool
}

func main() {
	a := Combine(&S{"Bob"}, &D{true})
	json.NewEncoder(os.Stderr).Encode(a)
}

func Combine(v ...interface{}) interface{} {
	f := make([]reflect.StructField, len(v))
	for i, u := range v {
		f[i].Type = reflect.TypeOf(u)
		f[i].Anonymous = true
	}

	r := reflect.New(reflect.StructOf(f)).Elem()
	for i, u := range v {
		r.Field(i).Set(reflect.ValueOf(u))
	}
	return r.Addr().Interface()
}

You could use something like the Combine function above to shmush any number of structs together. Unfortunately, from the documentation:

> StructOf currently does not generate wrapper methods for embedded fields. This limitation may be lifted in a future version.

So your created struct won't inherit methods from the embedded types. Still, maybe it does what you need.

If you are just looking to convert your interface to struct, use this method.

type Customer struct {
    Name string `json:"name"`
}

func main() {
    // create a customer, add it to DTO object and marshal it
    receivedData := somefunc() //returns interface

    //Attempt to unmarshall our customer
    receivedCustomer := getCustomerFromDTO(receivedData)
    fmt.Println(receivedCustomer)
}

func getCustomerFromDTO(data interface{}) Customer {
    m := data.(map[string]interface{})
    customer := Customer{}
    if name, ok := m["name"].(string); ok {
        customer.Name = name
    }
    return customer
}