Why don't changes made to a struct via a method persist?
The AddString method is using a value (copy) receiver. The modification is made to the copy, not the original. A pointer receiver must be used to mutate the original entity:
package main
import (
"fmt"
)
type Test struct {
someStrings []string
}
func (t *Test) AddString(s string) {
t.someStrings = append(t.someStrings, s)
t.Count() // will print "1"
}
func (t Test) Count() {
fmt.Println(len(t.someStrings))
}
func main() {
var test Test
test.AddString("testing")
test.Count() // will print "0"
}
Playground
Output
1
1
Your functions are defined on the object themselves rather than a pointer to the object.
func (this Test) AddString(s string) {
this.someStrings = append(this.someStrings, s)
this.Count() // will print "1"
}
The function above is defined on the concrete data. This means that when you call the function, the value of this
is passed in as a copy of the data. So any mutations you do to this
are done on the copy (in this case, the mutation is changing the pointer that 'someStrings' points to. We can rewrite the same function defined on a pointer of Test as jnml did:
func (this *Test) AddString(s string) {
this.someStrings = append(this.someStrings, s)
this.Count() // will print "1"
}
As you can see, the function definition is (this *Test)
instead of (this Test)
. This means that the variable this
is passed by reference, and any mutations that take place are mutations performed on the original object.