Add data to interface{} in struct

I want to add a data {"foo2": "bar2"} to data in struct sample at below fmt.Println(s) in main().

Script

type sample struct {
	data interface{}
}

func (s *sample) func1() {
	obj := map[string]interface{}{}
	obj["foo1"] = "bar1"
	s.data = obj
}

func main() {
	s := &sample{}
	s.func1()
	fmt.Println(s)

    // Above here is fixed as a condition of this question.
	// Here, I want to add {"foo2": "bar2"} to s.data

}

My tests

I tried below.

Test 1:

s.data["foo2"] = "bar2"

Error occurs. It's type interface {} does not support indexing.

Test 2:

obj := map[string]interface{}{}
t, _ := json.Marshal(s.data)
json.Unmarshal(t, &obj)
obj["foo2"] = "bar2"
fmt.Println(obj)

There are no errors. {"foo2": "bar2"} can be added.

Is this 2nd test effective or general method? If there are how to directly add data or other methods, will you please teach me.
Thank you so much for your time. And I'm sorry for my immature question.

I don't know for what reason you want to have an empty interface type instead of the map[string]interface{} type, but it can be done.

type sample struct {
    data interface{}
}

func (s *sample) func1() {
    obj := map[string]interface{}{}
    obj["foo1"] = "bar1"
    s.data = obj
}

func (s *sample) addField(key, value string) {
	v, _ := s.data.(map[string]interface{})
	v[key] = value
	s.data = v
}

func main() {
    s := &sample{}
    s.func1()
    fmt.Println(s)
    
    s.addField("foo2", "bar2")
    fmt.Println(s)
   
}

You have to cast the interface into a map[string]interface{} each time you want to add a value. This can also be done to retrieve a value, I'm sure you can add another method using what I provided to do that.

I would advise against doing this. Either you'll always have a map[string]interface{}, so you should make that the type of data, or you'll have to be careful as there is no guarantee that you have a map[string]interface{} so you'll have to handle this accordingly.

If you change the definition of your struct to:

type sample struct {
    data map[string]interface{}
}

it should work.

So why? Because you are defining data as interface{}. But you this is not a map it is an empty interface. Why it is not a map? Because it could be also an int, string or another struct. So you can not use that type like other types.

In your examples you are using data always as a map, so the solution would be to define data as the type map[string]interface{}