Swift Tutorial Part 3: Flow Control

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.

Leave a rating/review
Save for later
Share

Swift Tutorial Part 3: Flow Control

35 mins

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

Lorenzo Boaro

Contributors

Lorenzo Boaro

Author

Tech Editor

Editor

Illustrator

Final Pass Editor