Scoping in Go is built around the notion of code blocks. You can find several good explanations of how variable scoping work in Go on Google. I’d like to highlight one slightly unintuitive consequence of Go’s block scoping if you’re used to a language like Python, keeping in mind, this example does not break with Go’s notion of block scoping:
Let’s start with a common pattern in Python:
class Data(object):
def __init__(self, val):
self.val = val
def __repr__(self):
return('Data({})'.format(self.val))
li = [Data(2), Data(3), Data(5)]
print(li)
for d in li:
d.val += 1
print(li)
Output:
[Data(2), Data(3), Data(5)]
[Data(3), Data(4), Data(6)]
Here, we mutate val on each of the Data classes in the list and show our result at the end of the loop, confirming that each val was incremented. However, in Go, a similiar looking construction actually produces a different result:
package main
import "fmt"
func main() {
type Data struct {
val int
}
l := []Data{
{val: 2},
{val: 3},
{val: 5},
}
fmt.Printf("%+v\n", l)
for _, d := range l {
d.val += 1
}
fmt.Printf("%+v\n", l)
}
https://play.golang.org/p/O6vT7s8Qiym
Output:
[{val:2} {val:3} {val:5}]
[{val:2} {val:3} {val:5}]
So why does this happen? Block scoping.
Let’s look at simple example of block scoping:
package main
import "fmt"
func main() {
x := 1
fmt.Println(x)
if true {
x := 2
fmt.Println(x)
}
fmt.Println(x)
}
https://play.golang.org/p/1ebX4Oy92d0
Output:
1
2
1
The value of x changes after being assigned in the if statement code block, but is discarded after exiting the block.
We see the same behavior inside a for loop:
package main
import "fmt"
func main() {
x := "main"
fmt.Println(x)
for i := 0; i < 1; i++ {
x := "for"
fmt.Println(x)
}
fmt.Println(x)
}
https://play.golang.org/p/bOH2ObC5vS1
Output:
main
for
main
You can even create a code block with bare curly braces:
package main
import "fmt"
func main() {
x := "main"
fmt.Println(x)
{
x := "for"
fmt.Println(x)
}
fmt.Println(x)
}
https://play.golang.org/p/N1TWR29F12n
Output:
main
for
main
Now let’s return to our original example:
package main
import "fmt"
func main() {
type Data struct {
val int
}
l := []Data{
{val: 2},
{val: 3},
{val: 5},
}
fmt.Printf("%+v\n", l)
for _, d := range l {
d.val += 1
}
fmt.Printf("%+v\n", l)
}
https://play.golang.org/p/O6vT7s8Qiym
The loop variable d is in the block scope of the for loop. As we saw above, anything you do to a variable scoped to a block ceases to exist outside the block. So how can we actually change the value of the val field on the structs in the slice? We can’t use the loop variable, since it’s a value scoped to inside our loop.
Let’s try and get access the structs directly inside our loop. We’re actually not too far off:
package main
import "fmt"
func main() {
type Data struct {
val int
}
l := []Data{
{val: 2},
{val: 3},
{val: 5},
}
fmt.Printf("%+v\n", l)
for i, _ := range l {
l[i].val += 1
}
fmt.Printf("%+v\n", l)
}
https://play.golang.org/p/uo4ntARc0HG
Output:
[{val:2} {val:3} {val:5}]
[{val:3} {val:4} {val:6}]
Cool. It looks like we got the result we were looking for. But why does our first example work in Python? Python actually is hiding the use of values and pointers/references whereas Go requires us to handle them explictly. Using pointers in Go, we can construct a loop that behaves similarly to our Python example:
package main
import "fmt"
type Data struct {
val int
}
func main() {
l := []*Data{
{val: 2},
{val: 3},
{val: 5},
}
prettyPrint(l)
for _, d := range l {
d.val += 1
}
prettyPrint(l)
}
func prettyPrint(l []*Data) {
out := "["
for i, d := range l {
out += fmt.Sprintf("%+v", d)
if i != len(l)-1 {
out += " "
}
}
out += "]"
fmt.Println(out)
}
https://play.golang.org/p/bX6zbswFc3w
Output:
[&{val:2} &{val:3} &{val:5}]
[&{val:3} &{val:4} &{val:6}]
Note: we are now using a slice of *Data rather than a slice of Data. This example works similarly to the one in Python. Even though d is a variable scoped to the for loop, its value is a pointer that points to the same memory location as the pointers in l respectively. We can validate that in the following manner:
package main
import "fmt"
type Data struct {
val int
}
func main() {
l := []*Data{
{val: 2},
{val: 3},
{val: 5},
}
for i, d := range l {
fmt.Println("variable addresses")
println(&d)
println(&l[i])
fmt.Println("pointer addresses")
println(d)
println(l[i])
break
}
}
https://play.golang.org/p/q6l8cdllQy1
Output:
variable addresses
0x1042ff84
0x1042ff9c
pointer addresses
0x1042ff80
0x1042ff80
We see that the memory locations of the variables d and l[i] are different, but that they both point to the same memory location – the same struct in l.
You may wonder how in our earlier example we managed to mutate values in the slice without explicitly using pointers or references. We sidestepped these issues by using the slice l rather than a variable scoped to the for loop. The value of l[i] (where i is some index) is the same inside and outside the loop and references the same struct in memory. Here’s proof:
package main
func main() {
type Data struct {
val int
}
l := []Data{
{val: 2},
{val: 3},
{val: 5},
}
println(&l[0])
for i, _ := range l {
println(&l[i])
l[i].val += 1
break
}
}
https://play.golang.org/p/cIgaloLhcvQ
Output:
0x1042ff9c
0x1042ff9c
Note: To see a variable’s memory address println(&...) can be substituted with fmt.Println(unsafe.Pointer(&...))
Hope you enjoyed!