DevFright

Learn How to Create iOS Apps

What are Control Statements?

by Leave a Comment

Updated April 2025.

This article was originally published back in December 2012 and referred to a robot called Karel that was used in a Stanford programming course I followed in iTunes U. Although Karel was great at the time, and probably still is, it’s time to update this article.

Control Statements are found in any programming language and provide a way for the code to run differently based on conditions, wether that be a screen tapped, a time elapsed, a list created, and so on. You will see them through out your code.

Although control statements exist in any programming language, we’ll use the Swift syntax to work with them, given that this is a Swift programming blog.

What Are Control Statements?

Control statements manage the flow of your program in a few ways:

  1. They decide the flow of code using if and switch statements.
  2. They loop or repeat code with for or while.
  3. They jump by either skipping or exiting with break or continue.

Conditional Statements

For the first part of controlling flow in an app, we’ll look at the if, else, and guard statements.

The if statement

This is used to evaluate something to see if its true or false, and then run or not run code. It looks like this:

let userAge = 17

if userAge >= 18 {
    print("Welcome!")
} else {
    print("You are too young to use this app")
}

This simple example shows an expression that will be evaluated. We set the users age to 17 and then on line 3, we check to see “if” the userAge is greater or equal to 18. In this example, userAge is 17, so this evaluates to false and the first print is skipped over. Instead, it falls to the “else” and prints that they are too young to use the app.

With if statements, you will do a lot of evaluating to see if something is true or false. For example, if you are using Core Location to find out where the device is, “if” there is no location, then print a message saying that the users location cannot be found.

You are not just limited to either/or with “if” statements. You could do the following:

let userAge = 17

if userAge >= 18 {
    print("Welcome!")
} else if userAge >= 13 {
    print("Welcome to your limited experience")
} else {
    print("You are too young")
}

This example covers an extra condition. You can also add more than a single condition on a line. You might check if userAge >= 18 && <= 30 to fit in a range.

Order matters on if statments. In the example we just used, if userAge >= 13 was the first condition, then a 22 year old would get the limited experience because a 22 year old is 18 or older. So make sure you think through conditions to make sure that one isn’t being missed by being caught before by another condition.

The guard Statement

A guard can be used like an if, but to exit early. If you are searching for a user by name, you might pass in “Matthew” (that’s me), and if I am not in the database then exit and display a message. If I am there, continue on as normal.

func checkUser(username: String?) {
    guard let user = username else {
        print("User doesn't exist")
        return
    }
    print("Welcome, \(user)")
}

If the username does not exist then a message will be printed to inform that the user doesn’t exist. At this point it will return to the caller and the Welcome, user will not trigger.

Switch Statements

A switch statement is another way to control the flow through code. Like an if, if a condition matches it will run a particular line or lines of code. Switch statements provide a different way, and often more readable way to control flow.

enum NotificationType {
    case reminder, alert, message
}

func test(type: NotificationType) {

    switch type {
    case .reminder:
        print("Time to finish that task!")
    case .alert:
        print("Heads up—something’s happening!")
    case .message:
        print("You’ve got a new chat.")
    }
}

The sample code above begins by declaring an enum, or an enumeration, which is a group of related values. In this case, there are three NotificationTyles, one is reminder, one is alert, and the latter is message.

On line 5 we create a new method and pass in a NotificationType. We can call this by writing test(type: NotificationType.message). The switch statement on line 7 looks at this value passed in, which is NotificationType.message in this case. It then looks through each case:

Is it a reminder? No. Is it an alert? No. Is it a message. Yes!. It prints “You’ve got a new chat.”.

This could be achieved as an if by using if task == NotificationType.message, but using switch is cleaner in this example. If you have seen a switch statement before, you may have seen it with break added to the end of each case. You don’t need to do this in Swift.

Loops: for, while, and repeat-while

As well as using if/switch/guard statements, Swift also utilises loops for controling the flow of code. This is especially useful for times when looping over arrays of data.

for-in Loop

A for-in loop iterates over collections. 

let names = ["Rachel", "Matthew", "Paul", "Laura"]

The array above contains four strings, which happen to be four names. Perhaps you want to print these to the screen.

for name in names {
    print(name)
}

This example looks at names, and iterates over each name. In the example above, there are four names. It stores the first item in name and then we print that. It then gets to the second item, which is Matthew, and prints that, it then gets to Paul, then Laura and prints respectively. The for-in loop is exited when it iterates over the last item in the array.

for-in where filtering

The for-in loop can use a filter in the form of the “where” keyword.

for name in names where name.contains("l") {
    print(name)
}

The example above uses a where filter and will only display an item if it contains the “l” charachter. This will print three names to the screen and miss out Matthew.

while Loop

This loop will run until a condition fails. Be careful of these as you don’t want to get stuck in an infinite loop that never ends.

var seconds = 3

while seconds > 0 {
    print("\(seconds) seconds left...")
    seconds -= 1
}
print("Time’s up!")

In this example the loop will run “while” seconds is greater than zero. So on the first run, seconds is equal to 3 and it runs. It prints a message on screen.

seconds -= 1 takes 1 away from seconds and stores the result in seconds making the seconds variable contain the number 2.

2 still evaluates to be true because it is greater than 0, and the cycle repeats again. 2 then becomes 1 and it prints again, and then 1 becomes 0 and its false and “Time’s up!” prints.

Note that the while evaluation is at the beginning of the loop. If it evaluates to false then the code within the loop does not run. There may be instances where this loop does not run at all. This would happen if we set seconds to zero or lower (meaning a negative number).

repeat-while Loop

The repeat-while is a loop like the while loop, but the condition is evaluated at the end. This means that the loop runs at least once.

var attempts = 0

repeat {
    attempts += 1
    print("Attempt \(attempts)")
} while attempts < 3

In this example we are counting upwards. It prints the number of attempts and just prior to that , the 0 is incremented by 1. This means that the first run of the loop has Attempt printed as 1.

Because attempts is < 3 still, it runs again.

When it reaches 3 the loop then exits.

Both the while and repeat-while are similar, but are handled slightly differently.

break and continue

The break control statement is used to break out of a loop early. Perhaps you are looking for a number in an array of numbers. When you find that number, there’s no need to keep on looking, so you “break” out of it to continue with the rest of the code.

let places = ["Paris", "New York", "London", "Berlin", "Tokyo"]

for place in places {
    if place == "London" {
        print("Found London!")
        break
    }
    print("Checking \(place)")
}
... Next lines of code

The example above shows plays names. We put five cities in an array called places. We use a for-in loop and use an if condition to check if the place is equal to London. If it is we print that we found it and then break. Break skips to the end of the loop and carries on code execution on the next lines of code.

continue keyword

We can use “continue” when we want to skip to the next iteration.

for num in 1...10 {
    if num % 2 != 0 {
        print("\(num) is odd, skipping...")
        continue
    }
    print("\(num) is even, processing...")
}

In this example, we are using a for-in loop again, followed by an if statement within each iteration. This checks to see if the number is even or odd using the modulo (or remainder). If there’s a remainder then its off, and if its even, there will be no remainder. If we’re looking for even numbers we might execute some code and do more. However, if its odd, we just want to skip over the code onto the next number, so we add the continue keyword in, and it stops what its doing in the loop and checks the next number in the array.

Control statements are very powerful and will be used almost in every method, class, and logic that you create. If you are not too familiar with them yet, you will quickly catch up.

Leave a Reply