This lesson we're going to be taking a look at two key concepts when it comes to Go, related to controlling the flow of execution within our code. The first of these concepts is conditionals, which allows us to perform actions given a boolean expression or a boolean value, and the second is going to be loops, which allows us to repeat actions multiple times until a boolean condition has been met. Both of these concepts are foundational to the building blocks of applications and writing code, and they are perhaps the key reason of what makes software development so powerful. Let's begin by taking a look at conditional expressions.

In the last lesson we talked a little bit about the boolean type, which we defined, say using the isAdult expression as follows, setting it to be either true or false. Boolean values are the key building blocks of conditional expressions, which is where you can perform actions based on the outcome of either a boolean expression or the value stored inside of a boolean variable. To show how boolean expressions work, let's go ahead and define a variable called powerLevel, and we'll go ahead and initialize and set this to be 9001. Then let's say like one of my most favorite scenes from any anime, we want to go ahead and check this power level, and if it's over 9000, we then want to print out that it is.

To do so we can use the if keyword, which is the beginning of our conditional expression. Then we can apply some simple boolean logic. So if powerLevel is greater than 9001 or 9000, then we want to perform an action, which is defined inside of the curly braces. Inside of this we can go ahead and call fmt.Println and we'll go ahead and say "it's over 9000". We can also go ahead and say "fmt.Println("Vegeta, what does the scouter say about his power level"), let's say. And we'll do a couple of exclamation marks here.

Now if I go ahead and run this code, you can see we get "Vegeta, what does the scouter say about his power level", and we get the result of "it's over 9000". This is because the power level itself is over 9000. However, if we go ahead and set this to be, say, 8000, then our condition doesn't resolve to true, and we don't get the over 9000 response.

However, as you can see, Nappa, who has asked the original question - we can go ahead and say Nappa as follows - Nappa has asked Vegeta what does the scouter say about his power level, but as you can see, Vegeta isn't responding. So how do we get Vegeta to respond in the case that the powerLevel is not over 9000? Well, in order to do so, we need to use the else expression, which is used to perform an action if the conditional above it, the if expression, doesn't resolve to true.

So we can go ahead and say, we don't actually know what he says in this scene, but we could say, "Vegeta says it's nothing to worry about". Now if we go ahead and run this code, you can see this time our else expression is falling through due to the fact that the power level value is less than 9000. As well as performing boolean expressions within our if statement, we could just go ahead and actually capture this in a variable, so isOver9000, and we can go ahead and do powerLevel > 9000 as follows.

Then we could just do a simple if statement on this boolean expression, isOver9000. This works as well due to the fact that if statements require a boolean passed to them. In this case, we're checking is isOver9000, which is a boolean. However, if we just did if powerLevel, then you can see the compiler complains. This is because there's been a non-boolean condition applied to the if statement. Either no boolean has been given or no boolean conditional. Therefore, we would either need to use a direct check of if powerLevel > 9000, or we could pass in a boolean variable or even a boolean value.

Typically, unless I have a boolean value that exists already, or a boolean is being returned by a function or an expression, then I will default to checking the actual condition within the if statement, as this is a little bit more clear than, say, a boolean that is, say, isConcerning. And checking for isConcerning, we're not too sure what that boolean expression is. By looking at only the code we have on screen, we would have to also check for the definition of isConcerning.

So most of the time, I prefer to use the simple boolean expression in place when it makes sense to do so.

As you can see, boolean expressions are pretty useful when it comes to changing the flow of your code, but they can also be rather useful when it comes to preventing against panics. As we saw in the last lesson, we had a slice []string of names, defined as, defined similar to this. Let's go ahead and set this to be Goku, Vegeta, and Nappa.

When we tried to access this slice beyond its length, so we tried to access the third value of the slice, so let's go ahead and set fighter is equal to names[3], and we'll go ahead and print out the name of the fighter, and we'll print out the fighter's fighter.Name. When I go to run this code, you can see that we receive a panic of a runtime error, and the application crashes. The error is due to the fact that we're trying to index out of the range of the slice. We're trying to index at number 3 with a length of 3.

When it comes to production code, panics like this are generally a bad thing. Instead, you want to be able to handle your code in a way that's graceful, so if there aren't three values there, you would just either move on or return an error to the caller of the function. The best way to prevent this is to use a boolean conditional in order to check to see if the length of the slices is going to contain our index before we actually try to pull it out. We can do this by using an if statement, coupling it with the len function, so if len(names) >= 4, that's the amount we want to check, we can then go ahead and pull out the fighter at position 4 or index number 3.

Now when I go ahead and run this code, you can see we no longer get the crash, and if I go ahead and add in another name to this, let's say we can go ahead and add in piccolo, we can then run this again and it will now pass. When it comes to these sort of conditional checks, rather than checking >= 4, we can check > 3, which is the same expression, you can see it still works, and this way we can then define an index variable, say 3, and we could use this instead. This prevents the use of a magic number, which is where you have a hard-coded value.

These two numbers here are magic numbers. Instead, centralizing the number inside of a named variable, one, makes it easier for us to understand, and two, it prevents us from having a divergence when it comes to checking the length, and when it comes to pulling out the value. In any case, now our code is working and if we happen to have less fighters or less names, you can see that our code no longer panics as we're no longer trying to index an array beyond its length.

These sort of conditional expressions are known as guards, as they're guarding your code from executing given a certain condition. The other common expression that you use guards for is when it comes to checking for pointers, or checking to see if a pointer is non-nil. We'll talk about pointers later on however, but for the meantime, you can think of them as being very similar to the check we have for slices, checking for the existence of a value, and if so, then acting on it.

Of course, as we saw, you can also use the else statement if a conditional doesn't fall true. So we can go ahead and say fmt.PrintLine("no fighter"). However, what if instead we want to pull out another value if one doesn't exist? Let's say we want to pull out goku in that case. Well, we can do so by using what's known as an else if statement, which basically combines an else statement and an if statement.

Let's go ahead and quickly implement it to see how this works. Therefore, if len(names) > 0, and again, we could do a backup, and we'll set this to be 0 so we're not having magic numbers. So if len(names) > backup, then we can go ahead and pull out our backup fighter. So we'll do fighter := names[backup], and we'll do a fmt.PrintLn and say "subbing in fighter: %s", and we'll go fighter. Now, if I go ahead and run this, you can see we're subbing in the fighter Goku.

This is because, if we go ahead and actually split this out a little bit, just to make it a bit clearer. So let's take a quick look at the flow of this execution. First of all, we're checking to see if the length of names is greater than 3. Currently, it's not. It only has three elements inside, so the length is 3. Then we fall to the next else if statement. In this case, we're then checking to see if length of names is greater than the backup. The backup is 0, which, in this case, it is. Therefore, we're pulling out the value at index 0, which is Goku, and assigning it to our fighter variable.

Lastly, we then have the following else statement, which will trigger if all of the above if statements, either the if or else if's, are false. Therefore, this basically says if this is true, otherwise if this is true, otherwise perform this action. else if statements are very useful in order to be able to perform multiple conditionals within a single chain. However, they can fall victim to being rather verbose when you have a lot of statements in place.

Fortunately, Go provides another keyword that can help when checking for multiple conditional values. This is known as the switch keyword, which allows you to perform a switch statement. To use a switch statement, we first need to begin with an expression. In the case that we were seeing before, this would be the length of names. Then we can actually perform our conditional based on this. So if the length of names is 3, let's say, if it is, we can then go ahead and perform some code.

In this case, we could go ahead and pull out the name at index number 2, which is the third item. fmt.Println, fighter number three, let's say. Additionally, we can have multiple case statements here as well. So we could have a case for 2 if the length is 2, or a case for 1 if the length is 1. And we would have similar logic inside. Additionally, the switch statement also supports the default keyword, which allows you to perform an action if none of the cases are true, similar to the else statement when it comes to an if else chain.

In this case, whilst this works, using a switch statement to pull out names from a slice isn't the best approach we can take. Instead, if you want to pull out the last name, you can do so as follows. lastName = names[length(names) - 1]. This is a much better approach to pulling out names, but this does show how a switch statement works. Instead, a better use of a switch statement would be to say switch on the actual name itself.

So we can go ahead and do name = names[0]. Let's say we're getting the first name. Then we can do a switch on the name. And in this case, if it's goku, we can do something like fmt.Println, kaokan. If it's the case of vegeta, we can do something like fmt.Println, and we'll do Gallet Gun. Then say for everyone else, we can just do fmt.Println, fizzle. Let's say their special ability fizzled. In this case, we're just switching through the actual names that we receive.

And if we go ahead and run this, you can see that we have the name of goku, so the special ability is kaokan. That covers the basics of conditional expressions when it comes to Go. However, as I mentioned, the other common form of control flow that we'll be looking at is loops. Loops are an incredibly powerful construct when it comes to software development, as they allow you to repeatedly perform tasks until an expression is met.

To perform a loop in Go, you use the for keyword, which marks the start of a loop, or tells the compiler that a loop should take place. In Go, you can just use the for keyword by itself. And if we go ahead and print a statement of "hello", let's say, you'll see when I run this code, "hello" is just printed forever. Basically, this is looping infinitely. Let's press ctrl+c to cancel this.

Whilst this is cool, it's not exactly useful. Most of the time, you'll want to have some sort of counter or tracker or boolean expression in order to stop looping. For example, let's say we want our loop to stop after 10 times. Well, the simplest way we can do this is to define a variable called 10. Then we can go ahead and remove one from x in each iteration of our for loop. So we can go ahead and do x = x - 1, which means we're decrementing by one every time we iterate in our loop.

Then once x equals the value of 0, so when we run out a value in x, we can then use the following conditional expression. So if x = 0, then we'll go ahead and exit the loop by using the break keyword. Now we can go ahead and do "hello, x". And so we can actually see the numbers. Then when we run it, you can see we do 9, 8, 7, 6, 5, 4, 3, 2, 1.

Although I think I've actually got one, two, three, four, five, six, seven, eight, nine. Yeah, I've only got nine here. So I think we have to do this. Now when I go ahead and run this, you can see that it works. Although I did have a bug in the first place. That's because this isn't the easiest way to perform looping. There is in fact a better way. This is because the for keyword supports a boolean expression, which can be used to determine when the for loop should exit.

So if we go ahead and add in the boolean expression of x > 0, then we can go ahead and remove the if statement with the break keyword. Now if I go ahead and run this code, it should work the exact same way, which it does. Printing nine down to zero. Whilst we can decrement the value of x each time, it's actually more commonplace to go ahead and set x to be 0, so assigning the value of 0 to x. And then for the boolean condition of our for loop, we can go ahead and set for x < 10.

Inside of our loop, we can go ahead and do x++ or += 1 in order to increment the value of x each time we loop through. And we'll set this afterwards. Now when we go ahead and run this, you can see we do 10 loops again from 0 to 9. If we wanted to do this, we could do it as follows. And you can see this time we're printing 1 to 10. So whilst this works, again however, this isn't the easiest way to perform loops. Instead, Go provides a more shorthand syntax, which is based on the C programming language.

In this case, you would do for i = 0. You could have this set to be x, but i is the conventional value that you would use. So setting i to be 0, then if i < 10, as we already saw before, i++. This just increments the value of i each time we loop. Then let's replace our call to x with i. Now if I go ahead and run this, you can see "hello" is printed 10 times again, similar to what we saw before. But as you can see, it's a lot easier to understand what's going on. This is because all of the iteration logic is kept in line.

However, when it comes to Go, C-style loops are very rarely used. They do have some situations where they are useful, such as if you want to iterate between a range. So iterating between 5 and 10, which if I go ahead and run, you can see does so. However, most of the time we instead use the for range keyword. For example, let's say we want to iterate from 0 to 10 again. Here we can do for i shorthand assigning it to the value of range 10.

And we'll go ahead and add in the curly brace as well. Now when I go ahead and run this, you can see we're iterating from 0 to 9 as we were before. However, this time the syntax is a lot more clear. In addition to ranging over numbers, the range keyword can be used with many different values. For example, if we add our names back in, and this time we can go ahead and do a slice of goku, vegeta. Let's actually go ahead and set vegeta and nappa, let's say.

This time instead, we can actually range over the names slices. And we can go ahead and run them. As you can see, we're iterating three times. To pull these out, we could use the index value. So names[i], as we've seen before. And if we go ahead and run this, you can see we're now printing out the actual names of our values. Whilst this approach works, there is in fact a better approach we can take when it comes to the range keyword.

This is because when ranging over a slice and some other types as well, there's actually two values that are produced. The first is the index that we're ranging over. As you saw, 0, 1, 2. However, we can actually pull out the value that we're ranging over as well. For example, in this case, we're now pulling out the name. Then we can just go ahead and print out this name instead of pulling it out from the slice. Now we can go ahead and use the underscore here.

This then does the exact same thing. However, the benefits here is we're not actually pulling out the name via the index, which as we saw, if we got wrong, could cause a panic. Although this should never ever panic, because it will only iterate over the values inside of a slice. However, as you can see, this is much more clear as to what is actually happening. We're iterating over each value inside of the slice, and we're just saying, hello to it.

In addition to slices, the range keyword can also be used with maps. So let's say we have a map of string to string of finalPower or something like that. We'll do specialPower actually. And we can go ahead and set this to be a map of string with the key and string as the value. In this case, the key is going to be the name. So we can go ahead and do Goku's special power is, let's see, it's not kaokan.

kaokan is a special one, but it's actually kamehameha. I think that's how you spell it. And then vegeta, let's go ahead and give his the Final Flash. I love the Final Flash. I will capitalize it as well. Then for the special powers, we could pull these out as follows by using SpecialPower and then name. So we're passing in the name and if we go ahead and run this, you can see we do "Hello Kamehameha", "Hello Final Flash" and then "Hello blank" because we don't have a special power for Nappa.

Or if we just want to iterate over all of the keys and values, we can do so again by using the range keyword. So we can go ahead and do a for key, value := or we could just shorten these to for k, v :=. We can do range specialPower. This probably should be specialPowers actually. Then in this case, we can go ahead and do the fmt.Println special power for and we'll do the key and we'll do the value or v.

Let's go ahead and get rid of these names for the moment. Now when I go ahead and run this, you can see we're doing special power for goku is Kamehameha, specialPower for begeta is Final Flash. As I mentioned before, there are a number of different things you can use the range keyword for. And even more so since the release of Go 1.23, which brought function iterators to the language.

We won't be talking about those much in the course, but there are some situations where we may want to use them. However, through most of this course, we'll mainly be iterating over slices and maps. In any case, that covers the basics of control flow when it comes to the Go programming language, and how you can use both conditional expressions, if statements, and the for keyword in order to loop over them whilst also combining them together to perform powerful execution of your code in order to perform tasks multiple times.

As I mentioned, these are the building blocks of most applications when it comes to computer science and software development, so they're a very good thing to know. In the next lesson, we're going to talk about yet another component that makes software development so powerful, which are functions, specifically functions and packages, and how they relate in Go.