Golang Slice Indexing Value Or Reference?

I am learning go and is confused by the "thing" we get out of indexing a slice.
Consider that we have a struct of type bag:

type bag struct {
    item string
}

Then, consider that we have a list of bags:

itemBag := []bag{
    {item: "item1"},
    {item: "item2"},
    {item: "item3"}
}

Now, I try to change the content of the first element of our itemBag variable. Naively, I do the following:

item1 := itemBag[0]
item1.item = "not item1"

fmt.Printf("itemBag[0].item == 'not item1'? %v", itemBag[0].item == "not item1")

// console print false

I got the answer as false, because (I think, do correct me if I am wrong) when we do item1 := itemBag[0], we are making a copy of the value of itemBag[0] and assign it to item1. Which I believe is what is meant by this blog here.

To prove that, I try to obtain the pointer of the itemBag[0] instead and modify its value, and voila, I achieve what I wanted to do:

item1 := &itemBag[0]
item1.item = "not item1"

fmt.Printf("itemBag[0].item == 'not item1'? %v", itemBag[0].item == "not item1")

// console print true

Which makes a lot of sense if we say that when we do slice indexing (i.e. slice[index]) we'll get copy of its value instead of the underlying item.

Now, when I do the following instead:

itemBag[0].item = "not item1"

fmt.Printf("itemBag[0].item == 'not item1'? %v", itemBag[0].item == "not item1")

The result is true, which is not what I expected. Because it looks like itemBag[0].item is syntatically the same as if I first assign itemBag[0] to a variable and subsequently referring to its underlying item.

I feel like I am missing a basic chapter in the golang course, please, any redirection/explanation will be highly appreciated!

Tried googling things like "slice indexing pass by reference" but couldn't pinpoint the exact keywords to google.

Assignment operation copies values. So when you do:

item1 = itemBag[0]

you create a copy of the object at itemBag[0], which is of type bag. Now item1 has a copy of it, and any modifications you make to it will be made on the copy.

itemptr = &itemBag[0]

The right-side of the assignment is a pointer, so this operation creates a copy of that pointer and assigns it to itemptr. When you do itemptr.item="x", it is equivalent to (*itemptr).item=x, so the contents of the pointer is modified.

itemBag[0] is an addressable value, i.e. you can take the address of it.

https://go.dev/ref/spec#Address_operators

The expression itemBag[0].item is also an addressable value, so you can assign something to it, and it will be reflected in the slice itself.

The following, however, is not an addressable value:

m:=map[int]bag{1:bag{item:"str"}}
m[1].item="str1"

This is because m[1] returns a copy of a value in a map, and assigning a value to it would be lost. The following, however, is addressable:

m:=map[int]*bag{1:&bag{item:"str"}}
m[1].item="str1"

This would set the item field of the bag in the map.