# Swift Tutorial Part 3: Flow Control

**Swift 4.2, iOS 12, Xcode 10**Swift 4.2, iOS 12, Xcode 10

Welcome to part 3 of our Swift tutorial, where you’ll learn how code decisions using Booleans and repeat tasks using loops to control the flow. By Lorenzo Boaro.

### Sign up/Sign in

With a **free** Kodeco account you can download source code, track your progress,
bookmark, personalise your learner profile and more!

Already a member of Kodeco? Sign in

### Sign up/Sign in

With a **free** Kodeco account you can download source code, track your progress,
bookmark, personalise your learner profile and more!

Already a member of Kodeco? Sign in

### Sign up/Sign in

With a **free** Kodeco account you can download source code, track your progress,
bookmark, personalise your learner profile and more!

Already a member of Kodeco? Sign in

## Contents

## Swift Tutorial Part 3: Flow Control

35 mins

- Getting Started
- Boolean Operators
- Boolean Logic
- String Equality
- The if Statement
- Encapsulating Variables
- The Ternary Conditional Operator
- Loops
- While Loops
- Repeat-while Loops
- Breaking Out of a Loop
- Advanced Control Flow
- Ranges
- For Loops
- Continue Statement
- Switch Statements
- Advanced Switch Statements
- Partial Matching
- Where to Go From Here?

*Update note*: Lorenzo Boaro updated this tutorial to iOS 12, Xcode 10, and Swift 4.2. Matt Galloway wrote the original.

Welcome to the final part of this Swift mini-series! If you haven’t read through Part 1 or Part 2 of this series, we suggest you do that first.

In computer programming terms, the ability to tell the computer what to do in different scenarios is known as *control flow*.

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

At this point, you’ve seen a few types, 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 `Bool`

, which is short for Boolean, after 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 = true // Inferred to be of type Bool
let no = false // Inferred to be of type Bool
```

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 value 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 the values are the same (true) or they are different (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)
```

Evaluating this step by step: 1 does not equal 2, so (1==2) is `false`

, and then `!`

toggles `false`

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)
```

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, `>=`

operator lets you test if a value is greater than or equal to another.

### Boolean Logic

The examples above test just one condition. In order to combine multiple conditions to form a result, you can rely on Boolean logic.

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. For example, consider the following:

```
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
```

When you include parentheses around part of the expression, you specify the order of evaluation. First, Swift evaluates the sub-expression inside the parentheses, and then it evaluates the full expression, as follows:

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"
```

`dogEqualsCat`

is a Boolean that in this case equals `false`

, because `"dog"`

does not equal `"cat"`

.

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"`

.