# 3. Basic Control Flow Written by Matt Galloway

When writing a computer program, you need to be able 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. In this chapter, you’ll learn 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, one that will let 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 either 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).

``````let doesOneEqualTwo = (1 == 2)
``````
``````let doesOneNotEqualTwo = (1 != 2)
``````
``````let alsoTrue = !(1 == 2)
``````
``````let isOneGreaterThanTwo = (1 > 2)
let isOneLessThanTwo = (1 < 2)
``````

### 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.

``````let and = true && true
``````
``````let or = true || false
``````
``````let andTrue = 1 < 2 && 4 > 3
let andFalse = 1 < 2 && 3 > 4

let orTrue = 1 < 2 || 3 > 4
let orFalse = 1 == 2 || 3 == 4
``````
``````let andOr = (1 < 2 && 3 > 4) || 1 < 4
``````
``````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.

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

### Toggling a Bool

A `Bool` is often used to represent the state of something being “on” or “off”. In those cases, it’s common for the state to be toggled 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”.

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

## 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.")
}
``````
``````let animal = "Fox"

if animal == "Cat" || animal == "Dog" {
print("Animal is a house pet.")
} else {
print("Animal is not a house pet.")
}
``````
``````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)
``````

### Short circuiting

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

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

### 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:

``````var hoursWorked = 45

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

print(price)
``````
``````...

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

### 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.

``````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
}
``````
``````(<CONDITION>) ? <TRUE VALUE> : <FALSE VALUE>
``````
``````let a = 5
let b = 10

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

### 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>
}
``````
``````while true {  }
``````
``````var sum = 1

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

### 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>
``````
``````sum = 1

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

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

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

### 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 execution of the loop and continues on to the code after the loop.

``````sum = 1

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

### 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 if you 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 position 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.

### 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 n’th Fibonacci number. Remember that Fibonacci numbers start its 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 2 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:

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.