Go programming language is easy to learn, but there are some tricky traps. This article series is trying to show these booby traps so that you avoid them.
Trap#1
Let’s consider this code (code on the Playground):
-png-1.png)
In this example, we send an array by value to a function that modifies it. As we sent it by value, original value is not modified. Thus when we run it, we have:
-png-1.png)
Now let’s replace our array with a slice (code on the Playground):
-png-1.png)
When we run this example:
-png-1.png)
This might sound strange as we sent the slice by value, original should not have been modified!
Take five minutes to try to figure out why this happens and then have a look at the explanation below.
Explanation
When we send a slice by value, everything happens as if we had send it by reference. Slices behave as if we passed an array by reference (code on the Playground):
-png-1.png)
Which behaves as slices:
-png.png)
The explanation is quite simple: slices are structures that contain a reference to an array, as we can see in source code for slices:
-png-1.png)
Thus, when you pass a slice by value, the structure is copied, and the array is the same, and when you modify the array, the original slice points to the same array, and it is also modified
Trap#2
Let’s say we want to upper case first letter of names in User, as follows (code on the Playground):
-png-1.png)
If we run this code, we see that it doesn’t work as expected:
-png-1.png)
Why is this code not working? How could we fix it?
Explanation
This code doesn’t work as expected because in each loop, we copy struct User and thus when we modify it, original value is not updated.
We can fix it as follows (code on the Playground):
-png-1.png)
We modify the original value and thus it works as expected:
-png-1.png)
Conclusion
You should be aware that when we loop with range, we copy values and thus if we modify them, the original one is not.
Enjoy!
Your Comments :