In this lesson we're going to take a quick look at two key concepts when it comes to software development in Go: functions and pointers. We'll take a look at pointers later on in the lesson and how they relate to functions, however for the first part we're going to focus mainly on functions and the benefits they provide.

Functions are a key component of writing code, as they allow us to have code reusability and better organisation, by encapsulating logic into modular, self-contained units. So far we've actually interfaced with functions a couple of times already, specifically when we call the Println function of the fmt package and through defining the main function of our actual code.

Currently, if you take a look at the code I have on screen, I have a main function, which is initialising a data struct type of Fighter, which I've defined on line 3 to 7. This fighter has a number of fields inside - the first is a name, which is a string type, the second is a power level, which is an integer type and the third is a special ability, yet another string type. These are all very similar to the last lesson when we were looking at the various different attributes when it came to conditionals and for loops.

In this case we've just abstracted them into a single struct called Fighter, which means we're able to group these properties together. In this case we have a fighter called goku, which has the name goku, the power level of 9001 and the special ability of Kamehameha.

Let's say, similar to what we had in our last lesson, we want to be able to check the Powerlevel of goku, and if it's > 9000, we want to write to the console. We saw this in the last lesson of the simple if expression.

So if goku.PowerLevel > 9000, we can do format.Println, "it's over 9000". Then when I go ahead and run this code using the go run command, you can see it's printing out "it's over 9000". Pretty simple. But what if we have another fighter, let's say Vegeta, and in this case we can go ahead and quickly define his properties. So name is Vegeta. His power level is going to be, say, 18000. I'm not sure if we ever knew what his power level was. Maybe it's 21000. It would give him 30,000. That feels a bit more accurate to how strong he actually is. And in this case we'll do Final Flash. I think GalickGun is his ability at this stage, but we'll keep it as Final Flash.

However, let's say we also want to apply the same logic of checking Vegeta's power level. Well currently, in order to do so, we have to repeat the same code again. The same if statement. If Vegeta.powerLevel is greater than 9000, "it's over 9000". Whilst this approach works, it can be pretty tedious. Instead, it would be somewhat nicer if we could easily make this code repeatable, without us having to rewrite the same logic or the same check every time.

This is where functions can come in, as we can define a function that will take powerelevel as an argument, and we can use it to repeat the same functionality without having to write the implementation twice. To see how this works, let's go ahead and create a new function using the func keyword, and we'll give it a name of checkPowerlevel. Then inside of these parentheses, we can define some parameters that we want to pass in. In this case, we want to go ahead and pass in a variable called powerlevel, or an argument called powerLevel, which will have the type of integer, which is what we've defined our power level as for our individual fighter.

Then with that, we can go about implementing our actual function. In this case, all we need to do is check if powerlevel is greater than 9000, then we'll just write to the console, "it's over 9000". Now with that, we can go ahead and actually replace our two if statements by first deleting them, then we can just go ahead and call checkPowerlevel, passing in the power level of our individual fighters. So checkPowerlevel(goku.Powerlevel), checkPowerlevel(vegeta.Powerlevel). Now when we run this code, we should see that it works the same as it did before, printing "it's over 9000" twice.

However, this time, our check is only being written once. As you can see, we're now able to reuse this piece of code without us having to implement it twice, which helps to prevent bugs and makes it easier for us to extend this functionality to do other things. Currently, it's working as we saw before. However, we're not too sure which fighter this statement is related to. For example, if we go ahead and add in another fighter, let's say we add in Piccolo. I can never spell Piccolo, I think this is it, this is how you spell Piccolo. And he's going to be another fighter. We'll give him the name of Piccolo.

Piccolo, I think that's correct. PowerLevel, let's say we give him 8000. He was strong, but he wasn't as strong as Goku. And in this case, I can't remember what his special ability was. SpecialBeamCanon, that was it. SpecialBeamCanon. Okay, let's go ahead and set SpecialBeamCanon as Piccolo's special ability. Now, if we go ahead and do checkPowerlevel, and let's say we can do piccolo.Powerlevel, and we'll go ahead and add in an else statement of fmt.Println, "it's nothing to be worried about". We can go ahead and run this, and you can see we're getting our three outputs.

However, we're not too sure which of these fighters our output is related to. Well, we could go ahead and write in the format.Println statement here, saying "checking Goku", "checking Vegeta", and say "checking Piccolo". Now, when we go ahead and run this, whilst we are able to see what these PowerLevels are, we are again repeating our code. Fortunately for us, however, there is a better way. Rather than logging this out here, we could just go ahead and change the arguments that we accept inside of our function. So as well as checking a PowerLevel, we could just take a fighter name.

Let's change this to name. This is because functions themselves can support multiple parameters. So we can pass in multiple different arguments to this. Then we could just go ahead and do a format.Println here, and say "checking", and we'll just go ahead and pass in the name. Now, for all of our three functions, as you can see, they're now erroring because we're only passing in one argument, and we need to pass in two. So let's go ahead and do goku.Name, and we could do piccolo.Name. Now, if we go ahead and run this code again, you can see that we're printing out the fighter's name beforehand, before then checking their Powerlevel.

So far, so cool. However, whilst it's great to be able to pass in multiple parameters, in this case it would actually be easier to just go ahead and actually pass in our fighter struct, or our fighter type. This way, instead of passing in two parameters, we can instead just pass in one, and it will make our code less prone to bugs. For example, at the moment, we could accidentally pass in the Vegeta name when we're passing in the Goku Powerlevel. There's no protection against that. And if I go ahead and run this, you can see we're checking Vegeta twice, even though that's not actually the case.

So instead, let's go ahead and actually change our arguments from being powerlevel int and name string to just changing it to be the Fighter. So we can go ahead and say fighter Fighter. Then we can just reference this Fighter type, or the fields of this Fighter type, as follows. So fighter.Name, fighter.Powerlevel, undefined, oh yeah, fighter, there we go. Then, rather than passing in the two parameters as we're doing before, we can just go ahead and change this so that we can pass in, say, goku, vegeta, and we can do the same here, do piccolo.

Now when we run this code, it's operating the same as it is before, but this time we're ensuring that we aren't going to have a divergence on the two parameters that we're passing in, due to the fact that we're encapsulating all of our properties inside of a Fighter struct. So far, so good. As well as being able to accept values through parameters and arguments, functions themselves can also return values. For example, let's say we want to go ahead and create a new function called Kaokan. You'll notice this time I'm setting this to be an uppercase letter, this actually has a meaning when it comes to Go, and we'll talk about that more in a minute when we look at different packages.

In any case, for the moment we're specifying the Kaokan function, and we'll go ahead and pass in, say, the fighter that we want to Kaokan out. In this case, we can do this as follows. For this function, we want to take the fighter's power level, so fighter.Powerlevel, and we want to go ahead and multiply it by, say, * 5, let's say. We could also have a kaokanTimes, we can take this as an int as well, but for the moment we'll just hard-code this as the value 5.

In order to return the Kaokans's power level, we first need to be able to define that this function has a return parameter. We can do this by specifying the type after the parentheses, or after our parameter list. So in this case, we just want to return an int. Again, this type could be anything you want, such as a string or a float64. In this case, we're going to just return an int value. Then, in order to actually return a value, you just use the return keyword as follows, which tells the function that we're going to return this value that we've specified afterwards.

You can set a return pretty much anywhere you want inside of a function, although one thing to note is that any code afterwards, so fmt.Println("hello"), won't be executed after a return has been called. You can couple a return with an if statement, so in this case, if false, and we put it in here, this return will never happen, so our function will return, so our fmt.Println statement will execute, but as you notice, we don't have a return value. We could just return 0, but then we would get 0 back.

So just remember, when a return keyword is called, nothing will happen afterwards, the function will end, but you can use a conditional expression in order to control that behaviour. However, there must always be at least one return that takes place, even with the control flow. The compiler will help you out there, however.

In any case, here we're just returning the fighter.Powerlevel * 5. Now, if we go ahead and say Kaokan(goku), now we can say Koakan(goku) is going to be kaokan function, and we'll go passing goku, and if we go ahead and do a fmt.Println("new power level"), we can say, and we'll just go ahead and print out Kaokan(goku).

And let's go ahead and get rid of the vegeta and piccolo ones for the moment, just to make this a little bit more concise. Okay, so now we're calling Kaokan(Goku), and we're printing the Powerlevel out. If I go ahead and run this, you can see checking Goku, it's over 9,000. Now you can see his new power level is 45,005. Being able to return values when it comes to your functions is incredibly powerful for various different operations. For example, if we were creating a calculator app, we could add an Add function which took, say, a int, b int, and returned another int which was the summation of the two, as you can see.

However, there are some situations where you're going to want to modify the value that you pass in. For example, rather than returning the value for the Kaokan function, instead we just want to go ahead and set the fighter.PowerLevel = to equal his figher.PowerLevel * 5. In this case, we would just call the function as Kaokan(goku), and then we could go ahead and say check power level of goku as follows. And let's go ahead and do goku.Powerlevel. As you can see, we'll get rid of the check as well because we don't need it for the moment.

So in this case, we're going to do, say, old power level is goku's.powerLevel" after calling Kaokan on it. However, when I go to run this code, you can see the power level hasn't changed. However, if we take a look at the power level inside of the function, you'll see it actually has. If I go ahead and run this now, you can see inside of the function it's 45005, but outside of it, it's still 9001. So what's going on? This is because when you call a function, the value you pass in is copied.

So this fighter instance is not the same as this fighter instance. Even though it has the same values, they've just been copied over. Instead, in order to be able to modify the values inside of a function, we need to pass this in as a pointer. This basically changes our type from being a fighter type to being a pointer to a fighter type, which means it's pointing to the original memory or original data structure that this type points to. This means we're actually changing the original instance rather than changing the copy.

However, as you can see, the compiler or my editor is now complaining that we're passing in a type of fighter when we should be passing in a pointer of fighter. Fortunately, to solve that is pretty easy. We can use the & symbol or the ampersand symbol, which means to take the memory address of the fighter instance, thus turning this into a pointer. Now when I go ahead and run this code, you can see our new power level is set to 45,000. This is because we're now modifying the existing instance inside of our Kaokan function.

This actually brings us on to a good segue to talk about pointers and how they kind of work in Go. In Go, a pointer value allows you to pass around a value by its original memory address, rather than passing around a copy to a value. Pointers themselves can work with pretty much any type, so you can have a pointer to a string, a pointer to an int, or a pointer to a struct, as we saw here. For the most part, the main reason to use a pointer is so that you're able to modify the underlying value, as we saw when setting the power level inside of the Kaokan function.

However, there are some other reasons that you may want to use pointers, specifically if you want to define that an item may not exist, or in some cases in order to improve performance, although you're starting to get into tricky territory when you do this because sometimes using pointers can actually have a negative impact on performance. In any case, the reason that you would use pointers in order to communicate whether or not something exists is due to the fact that they support the nil value, which is used to denote the absence of a value.

However, the nil value itself can come with some caveats. For example, if we go ahead and set another fighter of vegeta, however this time we're going to go ahead and set vegeta to be a pointer to a fighter var vegeta *Fighter, rather than a fighter, which is what Goku currently is. If we now try to check the power level of Vegeta, and if I go ahead and run this code, you can see we get a panic. This is because vegeta has been set to be a null value, or a nil value. And when you try to dereference a nil value, i.e. use the following syntax of *vegeta to basically take the underlying value that Vegeta points to, it will end up causing your code to panic.

Therefore, in order to prevent this, we need to use what's known as a nil guard. So if vegeta != nil, as follows, then we will check his Powerlevel. In this case, you can see it's complaining because it is nil, as the compiler knows we've not initialized it. But now when I run this code, you can see that the checkPowerlevel for vegeta doesn't take place. And if we go ahead and assign vegeta to a value, which we can do using the vegeta := &Fighter, and we'll do Name: "Vegeta, Powerlevel, let's say we give him 30000, and special ability is, we'll give him "Gaelic Gun" this time.

Now as you can see, the code runs and we're checking vegeta.Powerlevel because vegeta is no longer nil. Again, this is complaining because it can see that the code is always going to be in this state.

As you can see, pointers can be incredibly useful when it comes to modifying values. However, for the most part, when it comes to Go, you should consider using non-pointer values, or static references, as it means your code is going to be a little less likely to break.

There are a couple of types, however, that have to be pointers regardless. These are the slice type, so a int[], and the map type as well, say a map[string]int. Both of these types are pointers by default. However, when it comes to slices, most of the methods you'll use with them will be safe regardless, so the len() function won't cause a crash, neither will the append function on a nil slice.

However, when it comes to the map, a nil map will panic if you try to add a key value pair to it. For example, if I just go ahead and set var names map[string]string, and we'll just go ahead and use var to set this to be a nil value. map[string]string. By the way, the empty value of both maps and slices is nil, and the empty value of a pointer is nil as well. Now, if I try to get rames, say Goku, and we can just go ahead and do names := names["goku"], and we'll just set this to be as follows, and we'll get rid of this.

Okay, so now I have a nil map because it's been initialized to its empty value, and we're trying to pull a name out of it. When I go ahead and run this, let's go ahead and actually save this file, and if I go ahead and run this code, you can see here this actually is safe. However, when I go to assign a value to it, so names["goku"] = "foo", now if I try to run this code, you can see we get a panic trying to assign an entry in a nil map. So whenever it comes to maps, it's always a good idea to make sure you have an initialization step, which honestly can be as simple as this names := map[string]string{}.

Now if I try to run this, you can see we no longer crash. Okay, that covers the basics of how to use functions when it comes to Go, as well as coupling it with pointers in order to be able to modify values. However, there's one last thing to talk about, which is packages. However, given that this video has gone on a little bit longer than I expected, we'll take a look at it then in another lesson. So I'm going to add a bonus lesson looking at packages and also visibility when it comes to Go. So I'll see you in the next lesson before we then move on to the actual course itself.