Remove an element of a slice in a struct [duplicate]

Question

This question already has an answer here:

• How to change struct variable content? 1 answer
• Why can't I append to a slice that's the property of a struct in golang? 1 answer

I have a struct "Guest" which contains metadata of a party guest (a unique ID, name, surname and a list of the unique IDs of the guests who are friends of this guest.

type Guest struct {
    id      int
    name    string
    surname string
    friends []int
}

I have the following code to remove an ID from the list of friends:

func (self Guest) removeFriend(id int) {
    for i, other := range self.friends {
        if other == id {
            self.friends = append(self.friends[:i], self.friends[i+1:]...)
            break
        }
    }
}

The problem is: The element I want to remove is overwritten by the shift of the elements, but the slice does not get shorter. Instead, the last element of the slice is multiplied.

To give an example: guest1.friends is [1,2,3,4,5]. After I call guest1.removeFriend(3), the result is [1,2,4,5,5] instead of the desired [1,2,4,5].

So, what am I doing wrong?

Answer 1

Any method that intends / does modify the receiver must use a pointer receiver.

Your Guest.removeFriend() method indeed tries to modify the receiver (of type Guest), namely its friends field (which is of slice type), but since you only used a value receiver, you are only modifying the friends field of a Guest copy. The original Guest value will have the unmodified slice value.

So you must use a pointer receiver:

func (self *Guest) removeFriend(id int) {
    // ...
}

Testing it:

g := &Guest{
    id:      1,
    name:    "Bob",
    surname: "Pats",
    friends: []int{1, 2, 3, 4, 5},
}

fmt.Println(g)
g.removeFriend(3)
fmt.Println(g)

Output (try it on the Go Playground):

&{1 Bob Pats [1 2 3 4 5]}
&{1 Bob Pats [1 2 4 5]}

The explanation for what you see in your version that slices are small struct descriptors pointing to an array that actually holds the elements. In your example you modified the elements of the backing array, so the caller having the original slice will see those modifications, but the size of the original slice will not (cannot) change.

By using a pointer receiver, you will assign the new slice value (returned by append()) to the friends field of the original Guest, the slice value whose length will be smaller by 1 (due to the 1 removed element).

Also note that in Go using receiver names like self and this is not idiomatic, instead you could use guest or simply g.