Swift Tutorial Part 3: Flow Control
Welcome to the third and final part of this Swift miniseries! If you haven’t read through Part 1 or Part 2 of this series, we suggest you do that first.
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 tapped the addition button and another thing if the user tapped the subtraction button.
In computerprogramming terms, this concept is known as control flow. It is so named because the flow of the program is controlled by various methods.
In this tutorial, 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.
Getting Started
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:
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 initial 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 notoperator, 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 was 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
.
In Swift, Boolean logic is usually applied to 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 subexpression inside the parentheses, and then it evaluates the full 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 as 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 is one value is greater than or less that 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"
.
The subject of equality brings up an interesting feature of Unicode: There are two ways to represent some characters. One example is the é
in café
, which is an e
with an acute accent. You can represent this character with either a single character or with two.
You saw the single character, code point 233, earlier in this tutorial. The twocharacter case is an e
on its own followed by an acute accent combining character, which is a special character that modifies the previous character.
So you can represent the e
with an acute accent by either of these means:
The combination of these two characters in the second diagram forms what is known as a grapheme cluster.
Another example of combining characters are the special characters used to change the skin color of certain emojis. For example:
Here, the thumbs up emoji is followed by a skin tone combining character. On platforms that support it, including iOS and macOS, the rendered emoji is a single thumbs up character with the skin tone applied.
Combining characters make equality of strings a little trickier. For example, consider the word café written once using the single é character, and once using the combining character, like so:
These two strings are of course logically equal. When they are printed onscreen, they look exactly the same. But they are represented inside the computer in different ways. Many programming languages would consider these strings to be unequal because those languages work by comparing the characters one by one. Swift, however, considers these strings to be equal by default. Let’s see that in action:
let stringA = "café"
let stringB = "cafe\u{0301}"
let equal = stringA == stringB
\u
followed by the code point in hexadecimal, in braces. You can use this shorthand to write any Unicode character. I had to use it here for the combining character because there’s no way to type this character on my keyboard!
In this case, equal
is true
, because the two strings are logically the same.
String comparison in Swift uses a technique known as canonicalization. Say that three times fast! Before checking equality, Swift canonicalizes both strings, which means they’re converted to use the same special character representation.
It doesn’t matter which way it does the canonicalization — using the single character or using the combining character — as long as both strings get converted to the same style. Once the canonicalization is complete, Swift can compare individual characters to check for equality.
Miniexercises

Create a constant called
myAge
and set it to your age. Then, create a constant calledisTeenager
that uses Boolean logic to determine if the age denotes someone in the age range of 13 to 19. 
Create another constant called
theirAge
and set it to my age, which is 30. Then, create a constant calledbothTeenagers
that uses Boolean logic to determine if both you and I are teenagers. 
Create a constant called
reader
and set it to your name as a string. Create a constant calledauthor
and set it to my name, Matt Galloway. Create a constant calledauthorIsReader
that uses string equality to determine ifreader
andauthor
are equal. 
Create a constant called
readerBeforeAuthor
which uses string comparison to determine ifreader
comes beforeauthor
.
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!
You can extend an if
statement to provide code to run in case 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"
, then the statement will run the first block of code. 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 elseif
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
let timeOfDay: String
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 elseif
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 24hour clock, the statements are checked onebyone in order:
 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
elseif
, 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 ifstatement, 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
as well. 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.
Let’s take an example. Imagine you want to calculate the fee to charge your client. Here’s the deal you’ve made:
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 and multiplies that by $50, 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 in which 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 of 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 the previous tutorial. 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:
() ? :
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 agree that’s much simpler! This is a useful operator that you’ll find yourself using regularly.
max
and min
. If you were paying attention earlier in this series, then you’ll recall you’ve already seen these.
Miniexercises

Create a constant called
myAge
and initialize it with your age. Write an if statement to print outTeenager
if your age is between 13 and 19, andNot a teenager
if your age is not between 13 and 19. 
Create a constant called
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 outanswer
.
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 {
}
Every iteration, the loop checks the condition. 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 is a while
loop that 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 very 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, up 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.
Repeatwhile Loops
A variant of the while
loop is called the repeatwhile 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 repeatwhile
loop like this:
repeat {
} while
Here’s the example from the last section, but using a repeatwhile
loop:
var 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:
var sum = 1
while sum < 1 {
sum = sum + (sum + 1)
}
And now consider the corresponding repeatwhile
loop, which uses the same condition:
var 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 repeatwhile
loop, however, sum
will equal 3
because the loop will execute 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 execution of the loop and continues on to the code after the loop.
For example, consider the following code:
var 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
. Neat!
You’ve seen how to write the same loop in different ways, demonstrating that in computer programming, there are often many ways to achieve the same result. 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.
Miniexercises

Create a variable named
counter
and set it equal to0
. Create a while loop with the conditioncounter < 10
which prints outcounter is X
(whereX
is replaced withcounter
value) and then incrementscounter
by1
. 
Create a variable named
counter
and set it equal to0
. Create another variable namedroll
and set it equal to0
. Create arepeatwhile
loop. Inside the loop, setroll
equal toInt(arc4random_uniform(6))
which means to pick a random number between0
and5
. Then incrementcounter
by1
. Finally, printAfter X rolls, roll is Y
whereX
is the value ofcounter
andY
is the value ofroll
. Set the loop condition such that the loop finishes when the first0
is rolled.
Key Points

You use the Boolean data type
Bool
to represent true and false. 
The comparison operators, all of which return a Boolean, are:
Equal: == Not equal: != Less than: < Greater than: > Less than or equal: <= Greater than or equal: >=
 You can use Boolean logic to combine comparison conditions.
 Swift’s use of canonicalization ensures that the comparison of strings accounts for combining characters.

You use
if
statements to make simple decisions based on a condition. 
You use
else
andelseif
within anif
statement to extend the decisionmaking 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 in place of simple
if
statements.  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 certain task a number of times until a condition is met.
 The break statement lets you break out of a loop.
First Challenges
Here are a few challenges before you head into the next section on advanced control flow:
 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

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)
 Suppose the squares on a chessboard are numbered left to right, top to bottom, with 0 being the topleft square and 63 being the bottomright square. Rows are numbered top to bottom, 0 to 7. Columns are numbered left to right, 0 to 7. Given a current position on the chessboard, expressed as a row and column number, calculate the next position on the chessboard, again expressed as a row and column number. The ordering is determined by the numbering from 0 to 63. The position after 63 is again 0.
 Given the coefficients a, b and c, calculate the solutions to a quadratic equation with these coefficients. Take into account the different number of solutions (0, 1 or 2). If you need a math refresher, this Wikipedia article on the quadratic equation will help https://en.wikipedia.org/wiki/Quadratic_formula.

Given a month (represented with a
String
in all lowercase) and the current year (represented with anInt
), 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. 
Given a number, determine if this number is a power of 2. (Hint: you can use
log2(number)
to find the base 2 logarithm ofnumber
.log2(number)
will return a whole number ifnumber
is a power of two. You can also solve the problem using a loop and no logarithm.)  Print a table of the first 10 powers of 2.
 Given a number n, calculate the nth Fibonacci number. (Recall Fibonacci is 1, 1, 2, 3, 5, 8, 13, ... Start with 1 and 1 and add these values together to get the next value. The next value is the sum of the previous two. So the next value in this case is 8+13 = 21.)
 Given a number n, calculate the factorial of n. (Example: 4 factorial is equal to 1 * 2 * 3 * 4.)
 Given a number between 2 and 12, calculate the odds of rolling this number using two sixsided dice. Compute it by exhaustively looping through all of the combinations and counting the fraction of outcomes that give you that value. Don't use a formula.
Advanced Control Flow
In this section, you’ll continue to learn how to control the flow of execution. You’ll learn about another loop known as the for
loop.
Loops may not sound very interesting, but they’re very common in computer programs. For example, you might have code to download an image from the cloud; with a loop, you could run that multiple times to download your entire photo library. Or if you have a game with multiple computercontrolled characters, you might need a loop to go through each one and make sure it knows what to do next.
You’ll also learn about switch
statements which are particularly powerful in Swift. They allow you to inspect a value and decide what to do based on its value. They’re incredibly powerful when used with some advanced Swift features such as pattern matching.
Ranges
Before you dive into the for
loop statement, you need to know about the Range data type, which lets you represent a sequence of numbers. Let’s look at two types of Range
.
First, there’s closed range, which you represent like so:
let closedRange = 0...5
The three dots (...
) indicate that this range is closed, which means the range goes from 0 to 5 inclusive. That’s the numbers (0, 1, 2, 3, 4, 5)
.
Second, there’s halfopen range, which you represent like so:
let halfOpenRange = 0..<5
Here, you replace the three dots with two dots and a lessthan sign (..<
). Halfopen means the range goes from 0 to 5, inclusive of 0 but not of 5. That’s the numbers (0, 1, 2, 3, 4)
.
Both open and halfopen ranges must always be increasing. In other words, the second number must always be greater than or equal to the first.
Ranges are commonly used in both for
loops and switch
statements, which means that throughout the rest of this section, you’ll use ranges as well!
For Loops
In the previous section, you looked at while
loops. Now that you know about ranges, it’s time to look at another type of loop: the for
loop. This is probably the most common loop you’ll see, and you’ll use it to run code a certain number of times.
You construct a for
loop like this:
for in {
}
The loop begins with the for
keyword, followed by a name given to the loop constant (more on that shortly), followed by in
, followed by the range to loop through.
Here’s an example:
let count = 10
var sum = 0
for i in 1...count {
sum += i
}
In the code above, the for
loop iterates through the range 1 to count
. At the first iteration of the loop, i
will equal the first element in the range: 1. Each time around the loop, i
will increment until it’s equal to count
; the loop will execute one final time and then finish.
i
equal to count  1
.
Inside the loop, you add i
to the sum
variable; it runs 10 times to calculate the sequence 1 + 2 + 3 + 4 + 5 + ...
all the way up to 10.
Here are the values of the constant i
and variable sum
for each iteration:

Start of iteration 1:
i
= 1,sum
= 0 
Start of iteration 2:
i
= 2,sum
= 1 
Start of iteration 3:
i
= 3,sum
= 3 
Start of iteration 4:
i
= 4,sum
= 6 
Start of iteration 5:
i
= 5,sum
= 10 
Start of iteration 6:
i
= 6,sum
= 15 
Start of iteration 7:
i
= 7,sum
= 21 
Start of iteration 8:
i
= 8,sum
= 28 
Start of iteration 9:
i
= 9,sum
= 36 
Start of iteration 10:
i
= 10,sum
= 45 
After iteration 10:
sum
= 55
In terms of scope, the i
constant is only visible inside the scope of the for
loop, which means it’s not available outside of the loop.
Xcode’s playground gives you a handy way to visualize such an iteration. Hover over the sum += i
line in the results pane, and you’ll see a white dot on the right. Hover over that dot to reveal a plus (+) button:
Click this plus (+) button and Xcode will display a graph underneath the line within the playground code editor:
This graph lets you visualize the sum
variable as the loop iterates.
Finally, sometimes you only want to loop a certain number of times, and so you don’t need to use the loop constant at all. In that case, you can employ the underscore to indicate you’re ignoring it, like so:
let count = 10
var sum = 1
var lastSum = 0
for _ in 0..
This code doesn’t require a loop constant; the loop simply needs to run a certain number of times. In this case, the range is 0 through count
and is halfopen. This is the usual way of writing loops that run a certain number of times.
It’s also possible to only perform the iteration under certain conditions. For example, imagine you wanted to compute a sum similar to that of triangle numbers, but only for odd numbers:
let count = 10
var sum = 0
for i in 1...count where i % 2 == 1 {
sum += i
}
The loop above has a where
clause in the for
loop statement. The loop still runs through all values in the range 1 to count
, but it will only execute the loop’s code block when the where
condition is true; in this case, where i
is odd.
Continue and Labeled Statements
Sometimes you’d like to skip a loop iteration for a particular case without breaking out of the loop entirely. You can do this with the continue
statement, which immediately ends the current iteration of the loop and starts the next iteration.
Note: In many cases, you can use the simpler where
clause you just learned about. The continue
statement gives you a higher level of control, letting you decide where and when you want to skip an iteration.
Take the example of an 8 by 8 grid, where each cell holds a value of the row multiplied by the column:
It looks much line a multiplication table, doesn’t it?
Let’s say you wanted to calculate the sum of all cells but exclude all even rows, as shown below:
Using a for
loop, you can achieve this as follows:
var sum = 0
for row in 0..<8 {
if row % 2 == 0 {
continue
}
for column in 0..<8 {
sum += row * column
}
}
When the row modulo 2 equals 0, the row is even. In this case, continue
makes the for
loop skip to the next row.
Just like break
, continue
works with both for
loops and while
loops.
The second code example will calculate the sum of all cells, excluding those where the column is greater than or equal to the row.
To illustrate, it should sum the following cells:
Using a for
loop, you can achieve this as follows:
var sum = 0
rowLoop: for row in 0..<8 {
columnLoop: for column in 0..<8 {
if row == column {
continue rowLoop
}
sum += row * column
}
}
This last code block makes use of labeled statements, labeling the two loops as rowLoop
and the columnLoop
, respectively. When the row equals the column inside the inner columnLoop
, the outer rowLoop
will continue.
You can use labeled statements like these with break
to break out of a certain loop. Normally, break
and continue
work on the innermost loop, so you need to use labeled statements if you want to manipulate an outer loop.
Miniexercises

Create a variable called
range
and set it equal to a range starting at 1 and ending with 10 inclusive. Write a for
loop which iterates over this range and prints the square of each number.

Write a
for
loop which iterates over the same range as in the exercise above and prints the square root of each number. Hint: you will need to type convert your loop variable.

Above, you saw a
for
loop which iterated over only the even rows like so:
var sum = 0
for row in 0..<8 {
if row % 2 == 0 {
continue
}
for column in 0..<8 {
sum += row * column
}
}
Change this to use a where
clause on the first for
loop to skip even rows instead of using continue
. Check that the sum is 448 as in the initial example.
Switch Statements
Another way to control flow is through the use of a switch
statement, which lets you execute different bits of code depending on the value of a variable or constant.
Here’s a very simple switch
statement that acts on an integer:
let number = 10
switch number {
case 0:
print("Zero")
default:
print("Nonzero")
}
In this example, the code will print the following:
Nonzero
The purpose of this switch
statement is to determine whether or not a number is zero. It will get more complex — I promise!
To handle a specific case, you use case
followed by the value you want to check for, which in this case is 0
. Then, you use default
to signify what should happen for all other values.
Here’s another example:
let number = 10
switch number {
case 10:
print("It's ten!")
default:
break
}
This time you check for 10, in which case, you print a message. Nothing should happen for other values. When you want nothing to happen for a case, or you want the default state to run, you use the break
statement. This tells Swift that you meant to not write any code here and that nothing should happen. Cases can never be empty, so you must write some code, even if it’s just a break
!
Of course, switch
statements also work with data types other than integers. They work with any data type! Here’s an example of switching on a string:
let string = "Dog"
switch string {
case "Cat", "Dog":
print("Animal is a house pet.")
default:
print("Animal is not a house pet.")
}
This will print the following:
Animal is a house pet.
In this example, you provide two values for the case, meaning that if the value is equal to either "Cat"
or "Dog"
, then the statement will execute the case.
Advanced Switch Statements
You can also give your switch
statements more than one case. In the previous section, you saw an if
statement using multiple elseif
statements to convert an hour of the day to a string describing that part of the day. You could rewrite that more succinctly with a switch
statement, like so:
let hourOfDay = 12
let timeOfDay: String
switch hourOfDay {
case 0, 1, 2, 3, 4, 5:
timeOfDay = "Early morning"
case 6, 7, 8, 9, 10, 11:
timeOfDay = "Morning"
case 12, 13, 14, 15, 16:
timeOfDay = "Afternoon"
case 17, 18, 19:
timeOfDay = "Evening"
case 20, 21, 22, 23:
timeOfDay = "Late evening"
default:
timeOfDay = "INVALID HOUR!"
}
print(timeOfDay)
This code will print the following:
Afternoon
Remember ranges? Well, you can use ranges to simplify this switch
statement. You can rewrite it using ranges as shown below:
let hourOfDay = 12
let timeOfDay: String
switch hourOfDay {
case 0...5:
timeOfDay = "Early morning"
case 6...11:
timeOfDay = "Morning"
case 12...16:
timeOfDay = "Afternoon"
case 17...19:
timeOfDay = "Evening"
case 20..<24:
timeOfDay = "Late evening"
default:
timeOfDay = "INVALID HOUR!"
}
This is more succinct than writing out each value individually for all cases.
When there are multiple cases, the statement will execute the first one that matches. You’ll probably agree that this is more succinct and more clear than using an if
statement for this example. It’s slightly more precise as well, because the if
statement method didn’t address negative numbers, which here are correctly deemed to be invalid.
It’s also possible to match a case to a condition based on a property of the value. As you learned in the first part of this tutorial series, you can use the modulo operator to determine if an integer is even or odd. Consider this code:
let number = 10
switch number {
case let x where x % 2 == 0:
print("Even")
default:
print("Odd")
}
This will print the following:
Even
This switch
statement uses the letwhere
syntax, meaning the case will match only when a certain condition is true. The let
part binds a value to a name, while the where
part provides a Boolean condition that must be true for the case to match. In this example, you’ve designed the case to match if the value is even — that is, if the value modulo 2 equals 0.
The method by which you can match values based on conditions is known as pattern matching.
In the previous example, the binding introduced a unnecessary constant x
; it’s simply another name for number
. You are allowed to use number
in the where
clause and replace the binding with an underscore to ignore it:
let number = 10
switch number {
case _ where number % 2 == 0:
print("Even")
default:
print("Odd")
}
Partial Matching
Another way you can use switch
statements with matching to great effect is as follows:
let coordinates = (x: 3, y: 2, z: 5)
switch coordinates {
case (0, 0, 0): // 1
print("Origin")
case (_, 0, 0): // 2
print("On the xaxis.")
case (0, _, 0): // 3
print("On the yaxis.")
case (0, 0, _): // 4
print("On the zaxis.")
default: // 5
print("Somewhere in space")
}
This switch
statement makes use of partial matching. Here’s what each case does, in order:

Matches precisely the case where the value is
(0, 0, 0)
. This is the origin of 3D space.

Matches y=0, z=0 and any value of x. This means the coordinate is on the xaxis.

Matches x=0, z=0 and any value of y. This means the coordinate is on the yaxis.

Matches x=0, y=0 and any value of z. This means the coordinate is on the zaxis.

Matches the remainder of coordinates.
You’re using the underscore to mean that you don’t care about the value. If you don’t want to ignore the value, then you can bind it and use it in your switch
statement, like this:
let coordinates = (x: 3, y: 2, z: 5)
switch coordinates {
case (0, 0, 0):
print("Origin")
case (let x, 0, 0):
print("On the xaxis at x = \(x)")
case (0, let y, 0):
print("On the yaxis at y = \(y)")
case (0, 0, let z):
print("On the zaxis at z = \(z)")
case let (x, y, z):
print("Somewhere in space at x = \(x), y = \(y), z = \(z)")
}
Here, the axis cases use the let
syntax to pull out the pertinent values. The code then prints the values using string interpolation to build the string.
Notice how you don’t need a default in this switch
statement. This is because the final case is essentially the default; it matches anything, because there are no constraints on any part of the tuple. If the switch
statement exhausts all possible values with its cases, then no default is necessary.
Also notice how you could use a single let
to bind all values of the tuple: let (x, y, z)
is the same as (let x, let y, let z)
.
Finally, you can use the same letwhere
syntax you saw earlier to match more complex cases. For example:
let coordinates = (x: 3, y: 2, z: 5)
switch coordinates {
case let (x, y, _) where y == x:
print("Along the y = x line.")
case let (x, y, _) where y == x * x:
print("Along the y = x^2 line.")
default:
break
}
Here, you match the “y equals x” and “y equals x squared” lines.
And those are the basics of switch
statements!
Miniexercises

Write a switch statement that takes an age as an integer and prints out the life stage related to that age. You can make up the life stages, or use my categorization as follows: 02 years, Infant; 312 years, Child; 1319 years, Teenager; 2039, Adult; 4060, Middle aged; 61+, Elderly.

Write a
switch
statement that takes a tuple containing a string and an integer. The string is a name, and the integer is an age. Use the same cases that you used in the previous exercise and let
syntax to print out the name followed by the life stage. For example, for myself it would print out "Matt is an adult."
.
Key Points

You can use ranges to create a sequence of numbers, incrementing to move from one value to another.

Closed ranges include both the start and end values.

Halfopen ranges include the start value and stop one before the end value.

For loops allow you to iterate over a range.

The continue statement lets you finish the current iteration of a loop and begin the next iteration.

Labeled statements let you use
break
and continue
on an outer loop.

You use
switch
statements to decide which code to run depending on the value of a variable or constant.

The power of a
switch
statement comes from leveraging pattern matching to compare values using complex rules.
Give these challenges a try to see if you fully understand the subtleties of loop and switch statements.
Second Challenges

In the following
for
loop:
var sum = 0
for i in 0...5 {
sum += i
}
What will be the value of sum
, and how many iterations will happen?

In the
while
loop below:
var aLotOfAs = ""
while aLotOfAs.characters.count < 10 {
aLotOfAs += "a"
}
How many instances of the character “a” will there be in aLotOfAs
? Hint: aLotOfAs.characters.count
will tell you how many characters there are in the string aLotOfAs
.

Consider the following
switch
statement:
switch coordinates {
case let (x, y, z) where x == y && y == z:
print("x = y = z")
case (_, _, 0):
print("On the x/y plane")
case (_, 0, _):
print("On the x/z plane")
case (0, _, _):
print("On the y/z plane")
default:
print("Nothing special")
}
What will this code print when coordinates
is each of the following?
let coordinates = (1, 5, 0)
let coordinates = (2, 2, 2)
let coordinates = (3, 0, 1)
let coordinates = (3, 2, 5)
let coordinates = (0, 2, 4)

A closed range can never be empty. Why?

Print a countdown from 10 to 0. (Note: do not use the
reversed()
method, which will be introduced later.)

Print 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0. (Note: do not use the
stride(from:by:to:)
function, which will be introduced later.)
Where to Go From Here?
You’ve learned a lot about the core language features for dealing with data over these past few tutorials — from data types to variables, then on to decisionmaking with Booleans and loops with ranges.
You can download the final playgrounds and challenges from the first part and second part of this tutorial here.
We encourage you to try the challenges above; if you find a particularly interesting solution to one of the challenges, or have any questions or comments on this tutorial, please tell us about it in the discussion below!
This tutorial was taken from Chapters 4 and 5 of Swift Apprentice, Second Edition available from the raywenderlich.com store.
The book has been completely updated to work with Xcode 8 and Swift 3. Check it out and let us know what you think!