Go (Golang) Tutorial #13 - Pass By Value

Key Takeaways

all right then gang so go is what's known as a pass by value language and this basically means that when we pass variables around as arguments in functions go makes a copy of those values for the function to use so we're going to dive into what that means for us as coders in this lesson so in go variable types can be split up into two distinct groups i'm just going to call these groups group a and group b for now but we'll give better names to them later on these are just the types that we've learned about so far plus an extra one called a struct which we're gonna learn about later on now there are other types which can go into these different groups but we've not covered those yet so i've left them out for now but understanding the difference between these two groups of types and how they work is pretty important and it's going to affect how you write go code so to demonstrate my point let's dive into a couple of examples first then we'll circle back around to the theory so i've got a name variable declared right here which is a string and remember that belongs to group a types strings ins bools floats arrays and structs so i have this string in this variable i've also created this function called update name and that takes in a string which we refer to as x and inside the function we take that string and we update the value of it to wedge so what if i call this function update name and i pass in the name variable which is t at the minute we take in that variable and we update the value of x that value to wedge inside the function then at the end down here we print out the name variable after we've run this function so what do you expect to see here do you expect to see tifa or wedge because we've updated the name inside this function you'd probably expect to see wedge but let's take a look and see what happens i'm going to open the console run the file go run main.go and we see tifa so it's not actually changed the value of the name inside this function so why not well what's happening is every time we pass a value or a variable into a function go creates a copy of the variable so this is a copy of the name variable not the original name variable and then inside here all we're doing is updating the copy of the variable and not the one we actually defined right here it creates a copy of that inside the function and that's the one we update which is why we still see tifa down here when we print it to the console so to understand this a bit more i want to talk about how variable values are stored on our computers in memory now our computer memory is a bit like a massive sequence of memory blocks where each block can store a single value now each block also has a unique memory address associated with it and our computer can use the memory address to either read values from or write values to that block now when we create a variable for example called age we store its value in one of these blocks and the variable name age acts as a label for this block and the memory address so that when we use a variable in our code our computer knows which block and which memory address is associated with and it can read the value inside that block now if we have another value or another variable its value is stored inside another block now when we pass one of these values into a function go copies that value and places it into another block whilst the function runs and this is the value that will be used inside that function now if we change that value inside the function it's this value we change not the original so when we print out the original variable after the function runs we still get its original value because it's not been changed only the copy has been changed so this is how passing around variables in go works a copy is created and stored in its own memory location so when passing variables in this group of types strings hints bools arrays floats and structs into a function as an argument changing the value of that argument inside the function does not change the original value it only changes the copy so one solution to this is to actually return a value here if we actually want to update this name so we could return x right here but we also have to specify the return type in the function at the top which is going to be a string so now what we could do is say well okay name is going to be updated to equal whatever this function returns to us in which case it's going to be wedge and if i save this now and run the file then we should see that it's updated to wedge right here awesome so that's the behavior of these types right here in group a now i want to move on to the other group of types group b so if we scroll down here a bit i've got commented out at the minute so let's just make it visible a menu which is a map and this remember is one of the group b types which is slices maps and functions so we have this map right here i'm also going to paste in a function at the top that i've created as well called update menu that takes in a map of exactly this type right here and we call that y inside the function and again we update y right here we say y this element is equal to 299 so the same as we did over here before before we returned a value we're just passing an item in the map and updating the map inside the function and then down here what i'm going to do is call that function update menu and pass in the menu and then i'm going to print out the menu so fmt dot print line menu so what do you think is going to happen here remember with this group of types right here it doesn't actually change the original value what's going to happen here is it going to change the original value or not well let's save it and find out so if we run the file then we can see right here the map and we can see now this coffee is 299. now it wasn't there in the original one so it's added in this element right here coffee is equal to 299. so which changed the original value of menu so what's going on here now the explanation i'm going to give you here is a simplistic version of what's happening under the hood so when we create a variable which is a type from group b go does two things first it stores the underlying data in memory in its own block and then it stores a value which contains other information including a pointer to the underlying data in another block and the variable name is associated with this memory block so in essence the value is split up into multiple memory locations the underlying data in one and a wrapper which contains a pointer to the underlying data in another now we'll learn more about pointers later but all they do is basically point to another memory location so when we use this variable in our code go find this block sees the pointer to the other memory block and reads from or writes to this underlying data so that when we pass this value as an argument into a function first go still does make a copy of the variable that bit doesn't change we always make a copy but it's copying the value stored inside this memory block where the pointer or the reference is stored not the underlying data that's not copied and now this copy contains the same pointer pointing to the same underlying data so when we change the variable inside the function go looks at the copied variable in memory it sees that it points to the other block then it updates the value in that block so it changes the original value so that's the difference between these two groups of data and how they work of these two groups of types if you like and how they work so to give these groups better names we'll call them pointer wrapper values and non-pointer values anyway now we know how these groups of types work i want to dive a little deeper and talk about pointers remember we said that pointers were the things that pointed to another memory block or memory location so we'll talk more about those next