# 3. Basic Control Flow Written by Matt Galloway

When writing a computer program, you need to tell the computer what to do in different scenarios. For example, a calculator app would need to do one thing if the user taps the addition button and another thing if the user taps the subtraction button.

In computer programming terms, this concept is known as control flow, named so because the flow of the program is controlled by various methods. This chapter will teach you how to make decisions and repeat tasks in your programs by using syntax to control the flow. You’ll also learn about Booleans, which represent true and false values, and how you can use these to compare data.

## Comparison operators

You’ve seen a few types now, such as `Int`, `Double` and `String`. Here you’ll learn about another type that lets you compare values through the comparison operators.

When you perform a comparison, such as looking for the greater of two numbers, the answer is either true or false. Swift has a data type just for this! It’s called a `Bool`, which is short for Boolean, after a rather clever man named George Boole who invented an entire field of mathematics around the concept of true and false.

This is how you use a Boolean in Swift:

``````let yes: Bool = true
let no: Bool = false
``````

And because of Swift’s type inference, you can leave off the type annotation:

``````let yes = true
let no = false
``````

A Boolean can only be true or false, denoted by the keywords `true` and `false`. In the code above, you use the keywords to set the state of each constant.

### Boolean operators

Booleans are commonly used to compare values. For example, you may have two values, and you want to know if they’re equal: either they are (true), or they aren’t (false).

In Swift, you do this using the equality operator, which is denoted by `==`:

``````let doesOneEqualTwo = (1 == 2)
``````

Swift infers that `doesOneEqualTwo` is a `Bool`. Clearly, 1 does not equal 2, and therefore `doesOneEqualTwo` will be `false`.

Similarly, you can find out if two values are not equal using the `!=` operator:

``````let doesOneNotEqualTwo = (1 != 2)
``````

This time, the comparison is true because 1 does not equal 2, so `doesOneNotEqualTwo` will be `true`.

The prefix `!` operator, also called the not-operator, toggles true to false and false to true. Another way to write the above is:

``````let alsoTrue = !(1 == 2)
``````

Because 1 does not equal 2, `(1 == 2)` is `false`, and then `!` flips it to `true`.

Two more operators let you determine if a value is greater than (`>`) or less than (`<`) another value. You’ll likely know these from mathematics:

``````let isOneGreaterThanTwo = (1 > 2)
let isOneLessThanTwo = (1 < 2)
``````

And it’s not rocket science to work out that `isOneGreaterThanTwo` will equal `false` and `isOneLessThanTwo` will equal `true`.

There’s also an operator that lets you test if a value is less than or equal to another value: `<=`. It’s a combination of `<` and `==`, and will therefore return `true` if the first value is either less than the second value or equal to it.

Similarly, there’s an operator that lets you test if a value is greater than or equal to another — you may have guessed that it’s `>=`.

### Boolean logic

Each of the examples above tests just one condition. When George Boole invented the Boolean, he had much more planned for it than these humble beginnings. He invented Boolean logic, which lets you combine multiple conditions to form a result.

One way to combine conditions is by using AND. When you AND together two Booleans, the result is another Boolean. If both input Booleans are `true`, then the result is `true`. Otherwise, the result is `false`.

In Swift, the operator for Boolean AND is `&&`, used like so:

``````let and = true && true
``````

In this case, `and` will be `true`. If either of the values on the right were `false`, then `and` would be `false`.

Another way to combine conditions is by using OR. When you OR together two Booleans, the result is `true` if either of the input Booleans is `true`. Only if both input Booleans are `false` will the result be `false`.

In Swift, the operator for Boolean OR is `||`, used like so:

``````let or = true || false
``````

In this case, `or` will be `true`. If both values on the right were `false`, then `or` would be `false`. If both were `true`, then `or` would still be `true`.

Swift uses boolean logic to evaluate multiple conditions. Maybe you want to determine if two conditions are true; in that case, you’d use AND. If you only care about whether one of two conditions is true, then you’d use OR.

For example, consider the following code:

``````let andTrue = 1 < 2 && 4 > 3
let andFalse = 1 < 2 && 3 > 4

let orTrue = 1 < 2 || 3 > 4
let orFalse = 1 == 2 || 3 == 4
``````

Each of these tests two separate conditions, combining them with either AND or OR.

It’s also possible to use Boolean logic to combine more than two comparisons. For example, you can form a complex comparison like so:

``````let andOr = (1 < 2 && 3 > 4) || 1 < 4
``````

The parentheses disambiguates the expression. First, Swift evaluates the sub-expression inside the parentheses, and then it evaluates the entire expression, following these steps:

``````1. (1 < 2 && 3 > 4) || 1 < 4
2. (true && false) || true
3. false || true
4. true
``````

### String equality

Sometimes you want to determine if two strings are equal. For example, a children’s game of naming an animal in a photo would need to determine if the player answered correctly.

In Swift, you can compare strings using the standard equality operator, `==`, in exactly the same way you compare numbers. For example:

``````let guess = "dog"
let dogEqualsCat = guess == "cat"
``````

Here, `dogEqualsCat` is a Boolean that in this case equals `false`, because `"dog"` does not equal `"cat"`. Simple!

Just as with numbers, you can compare not just for equality but also to determine if one value is greater than or less than another value. For example:

``````let order = "cat" < "dog"
``````

This syntax checks if one string comes before another alphabetically. In this case, `order` equals `true` because `"cat"` comes before `"dog"`.

Note: You will learn more about string equality in Chapter 9, “Strings”. Some interesting things crop up when strings contain special characters.

### Toggling a Bool

A `Bool` often represents the state of something being “on” or “off”. In those cases, it’s common for the state to toggle between states. For example, you could use a `Bool` to represent the state of a light switch in your application and toggle between the states “on” and “off”.

For these situations, there is a handy way to flip a `Bool` from `true` to `false` and back again. Like so:

``````var switchState = true
switchState.toggle() // switchState = false
switchState.toggle() // switchState = true
``````

Here, the variable called `switchState` starts as `true`. Then, after one `toggle`, it becomes `false`. After another `toggle`, it’s set to `true` again.

Note: The `toggle()` here is a call to a function. You’ll see more about these in Chapter 5, “Functions”, and how they apply to types in Chapter 12, “Methods”.

### Mini-exercises

1. Create a constant called `myAge` and set it to your age. Then, create a constant named `isTeenager` that uses Boolean logic to determine if the age denotes someone in the age range of 13 to 19.

2. Create another constant named `theirAge` and set it to my age, which is 30. Then, create a constant named `bothTeenagers` that uses Boolean logic to determine if both you and I are teenagers.

3. Create a constant named `reader` and set it to your name as a string. Create a constant named `author` and set it to my name, Matt Galloway. Create a constant named `authorIsReader` that uses string equality to determine if `reader` and `author` are equal.

4. Create a constant named `readerBeforeAuthor` which uses string comparison to determine if `reader` comes before `author`.

## The if statement

The first and most common way of controlling the flow of a program is through the use of an `if` statement, which allows the program to do something only if a certain condition is true. For example, consider the following:

``````if 2 > 1 {
print("Yes, 2 is greater than 1.")
}
``````

This is a simple `if` statement. If the condition is true, then the statement will execute the code between the braces. If the condition is false, then the statement won’t execute the code between the braces. It’s as simple as that!

At the heart of the `if` statement is the condition. The condition is the thing being checked, and then the code in the braces either runs or doesn’t. An `if` statement is, therefore, a form of conditional statement. You’ll see that term crop up again in this chapter.

You can extend an `if` statement to provide code to run if the condition turns out to be false. This is known as the else clause. Here’s an example:

``````let animal = "Fox"

if animal == "Cat" || animal == "Dog" {
print("Animal is a house pet.")
} else {
print("Animal is not a house pet.")
}
``````

Here, if `animal` equals either `"Cat"` or `"Dog"`, the statement will run the first code block. If `animal` does not equal either `"Cat"` or `"Dog"`, then the statement will run the block inside the `else` part of the `if` statement, printing the following to the debug area:

`Animal is not a house pet.`

But you can go even further than that with `if` statements. Sometimes you want to check one condition, then another. This is where `else-if` comes into play, nesting another `if` statement in the `else` clause of a previous `if` statement.

You can use it like so:

``````let hourOfDay = 12
var timeOfDay = ""

if hourOfDay < 6 {
timeOfDay = "Early morning"
} else if hourOfDay < 12 {
timeOfDay = "Morning"
} else if hourOfDay < 17 {
timeOfDay = "Afternoon"
} else if hourOfDay < 20 {
timeOfDay = "Evening"
} else if hourOfDay < 24 {
timeOfDay = "Late evening"
} else {
timeOfDay = "INVALID HOUR!"
}
print(timeOfDay)
``````

These nested `if` statements test multiple conditions one by one until a true condition is found. Only the code associated with that first true condition is executed, regardless of whether subsequent `else-if` conditions are true. In other words, the order of your conditions matters!

You can add an `else` clause at the end to handle the case where none of the conditions are true. This `else` clause is optional if you don’t need it; in this example, you do need it to ensure that `timeOfDay` has a valid value by the time you print it out.

In this example, the `if` statement takes a number representing an hour of the day and converts it to a string representing the part of the day to which the hour belongs. Working with a 24-hour clock, the statements are checked in order, one at a time:

• The first check is to see if the hour is less than 6. If so, that means it’s early morning.
• If the hour is not less than 6, the statement continues to the first `else-if`, where it checks the hour to see if it’s less than 12.
• Then, in turn, as conditions prove false, the statement checks the hour to see if it’s less than 17, then less than 20, then less than 24.
• Finally, if the hour is out of range, the statement prints that information to the console.

In the code above, the `hourOfDay` constant is `12`. Therefore, the code will print the following:

`Afternoon`

Notice that even though both the `hourOfDay < 20` and `hourOfDay < 24` conditions are also true, the statement only executes the first block whose condition is true; in this case, the block with the `hourOfDay < 17` condition.

### Short-circuiting

An important fact about `if` statements is what happens when there are multiple Boolean conditions separated by ANDs (`&&`) or ORs (`||`).

Consider the following code:

``````if 1 > 2 && name == "Matt Galloway" {
// ...
}
``````

The first condition of the `if` statement, `1 > 2` is `false`. Therefore the whole expression cannot ever be `true`.

So Swift will not even bother to check the second part of the expression, namely the check of `name`. Similarly, consider the following code:

``````if 1 < 2 || name == "Matt Galloway" {
// ...
}
``````

Since `1 < 2` is `true`, the whole expression must be `true` no matter what the value of `name` is. Therefore, once again, the check of `name` is not executed. This will come in handy later on when you start dealing with more complex data types.

### Encapsulating variables

`if` statements introduce a new concept scope, which is a way to encapsulate variables through the use of braces. Imagine you want to calculate the fee to charge your client. Here’s the deal you’ve made:

You earn \$25 for every hour up to 40 hours and \$50 for every hour after that.

Using Swift, you can calculate your fee in this way:

``````var hoursWorked = 45

var price = 0
if hoursWorked > 40 {
let hoursOver40 = hoursWorked - 40
price += hoursOver40 * 50
hoursWorked -= hoursOver40
}
price += hoursWorked * 25

print(price)
``````

This code takes the number of hours and checks if it’s over 40. If so, the code calculates the number of hours over 40, multiplies that by \$50 and then adds the result to the price. The code then subtracts the number of hours over 40 from the hours worked. It multiplies the remaining hours worked by \$25 and adds that to the total price.

In the example above, the result is as follows:

`1250`

The interesting thing here is the code inside the `if` statement. There is a declaration of a new constant, `hoursOver40`, to store the number of hours over 40. Clearly, you can use it inside the `if` statement. But what happens if you try to use it at the end of the above code?

``````...

print(price)
print(hoursOver40)
``````

This would result in the following error:

`Use of unresolved identifier 'hoursOver40'`

This error informs you that you’re only allowed to use the `hoursOver40` constant within the scope it was created. In this case, the `if` statement introduced a new scope, so when that scope is finished, you can no longer use the constant.

However, each scope can use variables and constants from its parent scope. In the example above, the scope inside the `if` statement uses the `price` and `hoursWorked` variables, which you created in the parent scope.

### The ternary conditional operator

Now I want to introduce a new operator, one you didn’t see in Chapter 2, “Types & Operations”. It’s called the ternary conditional operator and it’s related to `if` statements.

If you wanted to determine the minimum and maximum of two variables, you could use `if` statements, like so:

``````let a = 5
let b = 10

let min: Int
if a < b {
min = a
} else {
min = b
}

let max: Int
if a > b {
max = a
} else {
max = b
}
``````

By now, you know how this works, but it’s a lot of code. Wouldn’t it be nice if you could shrink this to just a couple of lines? Well, you can, thanks to the ternary conditional operator!

The ternary conditional operator takes a condition and returns one of two values, depending on whether the condition was true or false. The syntax is as follows:

``````(<CONDITION>) ? <TRUE VALUE> : <FALSE VALUE>
``````

You can use this operator to rewrite your long code block above, like so:

``````let a = 5
let b = 10

let min = a < b ? a : b
let max = a > b ? a : b
``````

In the first example, the condition is `a < b`. If this is true, the result assigned back to `min` will be the value of `a`; if it’s false, the result will be the value of `b`.

I’m sure you’ll agree that’s much simpler! This is a useful operator that you’ll find yourself using regularly.

Note: Because finding the greater or smaller of two numbers is such a common operation, the Swift standard library provides two functions for this purpose: `max` and `min`. If you were paying attention earlier in the book, then you’ll recall you’ve already seen these.

### Mini-exercises

1. Create a constant named `myAge` and initialize it with your age. Write an `if` statement to print out `Teenager` if your age is between 13 and 19 and `Not a teenager` if your age is not between 13 and 19.
2. Create a constant named `answer` and use a ternary condition to set it equal to the result you print out for the same cases in the above exercise. Then print out `answer`.

## Loops

Loops are Swift’s way of executing code multiple times. In this section, you’ll learn about one type of loop: the `while` loop. If you know another programming language, you’ll find the concepts and maybe even the syntax to be familiar.

### While loops

A `while` loop repeats a block of code while a condition is true. You create a `while` loop this way:

``````while <CONDITION> {
<LOOP CODE>
}
``````

The loop checks the condition for every iteration. If the condition is `true`, then the loop executes and moves on to another iteration. If the condition is `false`, then the loop stops. Just like `if` statements, `while` loops introduce a scope.

The simplest `while` loop takes this form:

``````while true {  }
``````

This `while` loop never ends because the condition is always `true`. Of course, you would never write such a `while` loop because your program would spin forever! This situation is known as an infinite loop, and while it might not cause your program to crash, it will likely cause your computer to freeze.

Here’s a more useful example of a `while` loop:

``````var sum = 1

while sum < 1000 {
sum = sum + (sum + 1)
}
``````

This code calculates a mathematical sequence to the point where the value is greater than `1000`.

The loop executes as follows:

• Before iteration 1: `sum` = 1, loop condition = true
• After iteration 1: `sum` = 3, loop condition = true
• After iteration 2: `sum` = 7, loop condition = true
• After iteration 3: `sum` = 15, loop condition = true
• After iteration 4: `sum` = 31, loop condition = true
• After iteration 5: `sum` = 63, loop condition = true
• After iteration 6: `sum` = 127, loop condition = true
• After iteration 7: `sum` = 255, loop condition = true
• After iteration 8: `sum` = 511, loop condition = true
• After iteration 9: `sum` = 1023, loop condition = false

After the ninth iteration, the `sum` variable is `1023`, and therefore the loop condition of `sum < 1000` becomes false. At this point, the loop stops.

### Repeat-while loops

A variant of the `while` loop is called the repeat-while loop. It differs from the `while` loop in that the condition is evaluated at the end of the loop rather than at the beginning. You construct a `repeat-while` loop like this:

``````repeat {
<LOOP CODE>
} while <CONDITION>
``````

Here’s the example from the last section, but using a `repeat-while` loop:

``````sum = 1

repeat {
sum = sum + (sum + 1)
} while sum < 1000
``````

In this example, the outcome is the same as before. However, that isn’t always the case — you might get a different result with a different condition.

Consider the following `while` loop:

``````sum = 1

while sum < 1 {
sum = sum + (sum + 1)
}
``````

Consider the corresponding `repeat-while` loop, which uses the same condition:

``````sum = 1

repeat {
sum = sum + (sum + 1)
} while sum < 1
``````

In the case of the regular `while` loop, the condition `sum < 1` is `false` right from the start. That means the body of the loop won’t be reached! The value of `sum` will equal `1` because the loop won’t execute any iterations.

In the case of the `repeat-while` loop, `sum` will equal `3` because the loop executes once.

### Breaking out of a loop

Sometimes you want to break out of a loop early. You can do this using the `break` statement, which immediately stops the loop’s execution and continues on to the code after the loop.

For example, consider the following code:

``````sum = 1

while true {
sum = sum + (sum + 1)
if sum >= 1000 {
break
}
}
``````

Here, the loop condition is `true`, so the loop would normally iterate forever. However, the `break` means the `while` loop will exit once the sum is greater than or equal to `1000`.

You’ve seen how to write the same loop in different ways, demonstrating that there are often many ways to achieve the same result in computer programming.

You should choose the method that’s easiest to read and conveys your intent in the best way possible. This is an approach you’ll internalize with enough time and practice.

### Mini-exercises

1. Create a variable named `counter` and set it equal to `0`. Create a while loop with the condition `counter < 10`, which prints out `counter is X` (where `X` is replaced with `counter` value) and then increments `counter` by `1`.
2. Create a variable named `counter` and set it equal to `0`. Create another variable named `roll` and set it equal to `0`. Create a `repeat-while` loop. Inside the loop, set `roll` equal to `Int.random(in: 0...5)` which means to pick a random number between `0` and `5`. Then increment `counter` by `1`. Finally, print `After X rolls, roll is Y` where `X` is the value of `counter` and `Y` is the value of `roll`. Set the loop condition such that the loop finishes when the first `0` is rolled.

## Challenges

Before moving on, here are some challenges to test your knowledge of basic control flow. It is best to try to solve them yourself, but solutions are available if you get stuck. These came with the download or are available at the printed book’s source code link listed in the introduction.

### Challenge 1: Find the error

What’s wrong with the following code?

``````let firstName = "Matt"

if firstName == "Matt" {
let lastName = "Galloway"
} else if firstName == "Ray" {
let lastName = "Wenderlich"
}
let fullName = firstName + " " + lastName
``````

### Challenge 2: Boolean challenge

In each of the following statements, what is the value of the Boolean `answer` constant?

``````let answer = true && true
let answer = false || false
let answer = (true && 1 != 2) || (4 > 3 && 100 < 1)
let answer = ((10 / 2) > 3) && ((10 % 2) == 0)
``````

### Challenge 3: Snakes and ladders

Imagine you’re playing a game of snakes & ladders that goes from position 1 to position 20. On it, there are ladders at positions 3 and 7, which take you to 15 and 12, respectively. Then there are snakes at positions 11 and 17, which take you to 2 and 9, respectively.

Create a constant called `currentPosition`, which you can set to whatever position between 1 and 20 you like. Then create a constant called `diceRoll`, which you can set to whatever roll of the dice you want. Finally, calculate the final position considering the ladders and snakes, calling it `nextPosition`.

### Challenge 4: Number of days in a month

Given a month (represented with a `String` in all lowercase) and the current year (represented with an `Int`), calculate the number of days in the month. Remember that because of leap years, “february” has 29 days when the year is a multiple of 4 but not a multiple of 100. February also has 29 days when the year is a multiple of 400.

### Challenge 5: Next power of two

Given a number, determine the next power of two above or equal to that number.

### Challenge 6: Triangular number

Given a number, print the triangular number of that depth. You can get a refresher of triangular numbers here: https://en.wikipedia.org/wiki/Triangular_number

### Challenge 7: Fibonacci

Calculate the nth Fibonacci number. Remember that Fibonacci numbers start their sequence with 1 and 1, and then subsequent numbers in the sequence are equal to the previous two values added together. You can get a refresher here: https://en.wikipedia.org/wiki/Fibonacci_number

### Challenge 8: Make a loop

Use a loop to print out the times table up to 12 of a given factor.

### Challenge 9: Dice roll table

Print a table showing the number of combinations to create each number from 2 to 12, given two six-sided dice rolls. You should not use a formula but rather compute the number of combinations exhaustively by considering each possible dice roll.

## Key points

• You use the Boolean data type `Bool` to represent true and false.
• The comparison operators, all of which return a Boolean, are:

• You can use Boolean logic (`&&` and `||`) to combine comparison conditions.
• You use `if` statements to make simple decisions based on a condition.
• You use `else` and `else-if` within an `if` statement to extend the decision-making beyond a single condition.
• Short-circuiting ensures that only the minimal required parts of a Boolean expression are evaluated.
• You can use the ternary operator `(a ? b : c)` instead of a simple `if` statement.
• Variables and constants belong to a certain scope, beyond which you cannot use them. A scope inherits visible variables and constants from its parent.
• `while` loops allow you to perform a particular task zero or more times until a condition is met.
• `repeat` loops always execute the loop at least once.
• The `break` statement lets you break out of a loop.
Have a technical question? Want to report a bug? You can ask questions and report bugs to the book authors in our official book forum here.