# 4 Basic Control Flow Written by Irina Galata

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 computer-programming 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 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.

Open up a project in IntelliJ to follow along!

## 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. Kotlin has a data type just for this! It’s called a `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 Kotlin:

``````val yes: Boolean = true
val no: Boolean = false
``````

And because of Kotlin’s type inference, you can leave off the type annotation:

``````val yes = true
val 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).

In Kotlin, you do this using the equality operator, which is denoted by `==`. Try it out:

``````val doesOneEqualTwo = (1 == 2)
``````

Kotlin infers that `doesOneEqualTwo` is a `Boolean`. 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:

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

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

``````val isOneGreaterThanTwo = (1 > 2)
val 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 Kotlin, the operator for Boolean AND is `&&`, used like so:

``````val 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 Kotlin, the operator for Boolean OR is `||`, used like so:

``````val 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 Kotlin, 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:

``````val andTrue = 1 < 2 && 4 > 3
val andFalse = 1 < 2 && 3 > 4

val orTrue = 1 < 2 || 3 > 4
val 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:

``````val andOr = (1 < 2 && 3 > 4) || 1 < 4
``````

The parentheses disambiguates the expression. First Kotlin evaluates the sub-expression 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 Kotlin, you can compare strings using the standard equality operator, `==`, in exactly the same way as you compare numbers. For example:

``````val guess = "dog"
val 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 if one value is greater than or less that another value. For example:

``````val order = "cat" < "dog"
``````

This syntax checks if one string comes before another alphabetically. In this case, `order` equals `true` because `"cat"` comes before `"dog"`.

### Mini-exercises

1. Create a constant called `myAge` and set it to your age. Then, create a constant named `isTeenager` that uses Boolean logic to determine if the age denotes someone in the age range of 13 to 19.
2. Create another constant named `theirAge` and set it to the age 30. Then, create a constant named `bothTeenagers` that uses Boolean logic to determine if both you and them are teenagers.
3. Create a constant named `reader` and set it to your name as a string. Create a constant named `author` and set it to the name Richard Lucas. Create a constant named `authorIsReader` that uses string equality to determine if `reader` and `author` are equal.
4. Create a constant named `readerBeforeAuthor` which uses string comparison to determine if `reader` comes before `author`.

## The if expression

The first and most common way of controlling the flow of a program is through the use of an `if` expression, which allows the program to do something only if a certain condition is true. For example, try typing out and running the following:

``````if (2 > 1) {
println("Yes, 2 is greater than 1.")
}
``````

This is a simple `if` expression. If the condition is true, then the expression will execute the code between the braces. If the condition is false, then the expression won’t execute the code between the braces. It’s as simple as that!

The term `if` expression is used here instead of `if` statement, since, unlike many other programming languages, a value is returned from the `if` expression. The value returned is the value of the last expression in the `if` block.

You are not required to use the returned value or assign it to a variable. You’ll see more on returning a value below.

### The else expression

You can extend an `if` expression 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:

``````val animal = "Fox"

if (animal == "Cat" || animal == "Dog") {
println("Animal is a house pet.")
} else {
println("Animal is not a house pet.")
}
``````

Here, if `animal` equals either `"Cat"` or `"Dog"`, then the expression will run the first block of code. If `animal` does not equal either `"Cat"` or `"Dog"`, then the expression will run the block inside the `else` part of the `if` expression, printing the following to the console:

``````Animal is not a house pet.
``````

You can also use an `if-else` expression on one line. Let’s take a look at how this can make your code more concise and readable.

If you wanted to determine the minimum and maximum of two variables, you could use `if` expressions like so:

``````val a = 5
val b = 10

val min: Int
if (a < b) {
min = a
} else {
min = b
}

val max: Int
if (a > b) {
max = a
} else {
max = b
}
``````

By now you know how this works, but it’s a lot of code. Let’s take a look at how we can improve this using the fact that the `if-else` expression returns a value.

Simply remove the brackets and put it all on one line, like so:

``````val a = 5
val b = 10

val min = if (a < b) a else b
val max = if (a > b) a else 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`. So `min` is set to 5. In the second example, `max` is assigned the value of `b`, which is 10.

I’m sure you’ll agree that’s much simpler! This is an example of idiomatic code, which means you are writing code in the expected way for a particular programming language. You want to use idioms whenever they make your code clearer, as it not only makes the code better, but it allows other developers familiar with the language to comprehend your code quickly.

Note: Because finding the greater or smaller of two numbers is such a common operation, the Kotlin standard library provides two functions for this purpose: `max()` and `min()`. If you were paying attention earlier in the book, then you’ll recall you’ve already seen these.

### The else-if expression

But you can go even further than that with `if` expressions. Sometimes you want to check one condition, then another. This is where `else-if` comes into play, nesting another `if` clause in the `else` clause of a previous `if` clause.

You can use `else-if` like so:

``````val hourOfDay = 12

val timeOfDay = if (hourOfDay < 6) {
"Early morning"
} else if (hourOfDay < 12) {
"Morning"
} else if (hourOfDay < 17) {
"Afternoon"
} else if (hourOfDay < 20) {
"Evening"
} else if (hourOfDay < 24) {
"Late evening"
} else {
"INVALID HOUR!"
}
println(timeOfDay)
``````

These nested `if` clauses 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 `else-if` 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` expression 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 24-hour clock, the conditions are checked in order, one at a time:

• 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 expression continues to the first `else-if`, where it checks the hour to see if it’s less than 12.
• Then in turn, as conditions prove false, the expression 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 expression returns that the value is invalid.

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 expression only executes and returns the first block whose condition is true; in this case, the block with the `hourOfDay < 17` condition.

### Short circuiting

An important fact about `if` expressions and the Boolean operators 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 `if` expression, `1 > 2` is `false`. Therefore the whole expression cannot ever be `true`. So Kotlin 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` expressions 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:

You earn \$25 for every hour up to 40 hours, and \$50 for every hour thereafter.

Using Kotlin, you can calculate your fee in this way:

``````var hoursWorked = 45

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

println(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` expression. 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?

``````println(price)
println(hoursOver40)
``````

This would result in the following error:

``````Unresolved reference: '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` expression 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` expression uses the `price` and `hoursWorked` variables, which you created in the parent scope.

### Mini-exercises

1. Create a constant named `myAge` and initialize it with your age. Write an `if` expression 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 called `answer` and use a single line `if-else` expression 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 Kotlin’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 */
}
``````

The loop checks the condition for every iteration. 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` expressions, `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.

### Repeat-while loops

A variant of the `while` loop is called the do-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 `do-while` loop like this:

``````do {
/* LOOP CODE */
} while (/* CONDITION */)
``````

Here’s the example from the last section, but using a `repeat-while` loop:

``````sum = 1

do {
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:

``````sum = 1

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

Consider the corresponding `do-while` loop, which uses the same condition:

``````sum = 1

do {
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 because the condition is checked at the beginning! The value of `sum` will equal `1` because the loop won’t execute any iterations.

In the case of the `do-while` loop, `sum` will equal `3` because the loop executes once and then the condition is checked for the first time.

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

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

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.

### 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 `do-while` loop.

Inside the loop, set `roll` equal to `Random().nextInt(6)` which means to pick a random number between `0` and `5`. Then increment `counter` by `1`.

Note: Add the line `import java.util.*` to the top of your Kotlin file to be able to use `Random`.

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

Time to test your knowledge! If you need any help along the way, check out the solutions in the materials for this chapter.

1. What’s wrong with the following code?
``````val firstName = "Joe"

if (firstName == "Howard") {
val lastName = "Lucas"
} else if (firstName == "Ray") {
val lastName = "Wenderlich"
}

val fullName = firstName + " " + lastName
``````
1. In each of the following statements, what is the value of the Boolean `answer` constant?
``````val answer1 = true && true
val answer2 = false || false
val answer3 = (true && 1 != 2) || (4 > 3 && 100 < 1)
val answer4 = ((10 / 2) > 3) && ((10 % 2) == 0)
``````
1. Suppose the squares on a chessboard are numbered left to right, top to bottom, with 0 being the top-left square and 63 being the bottom-right 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.

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

Note: Add `import kotlin.math.sqrt` to the top of your file to access the `sqrt` operation.

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

2. Given a number as a `Double` value, determine if this number is a power of 2.

Hint: You can use `log2(number)` to find the base 2 logarithm of `number`. `log2(number)` will return a whole number if `number` is a power of two. Add `import kotlin.math.log2` to the top of your file to use `log2`.

You can also solve the problem using a loop and no logarithm.

1. Print a table of the first 10 powers of 2.

2. Given a number n, calculate the n-th 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.)

3. Given a number n, calculate the factorial of n. (Example: 4 factorial is equal to 1 * 2 * 3 * 4.)

4. Given a number between 2 and 12, calculate the odds of rolling this number using two six-sided 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.

## Key points

• You use the Boolean data type `Boolean` 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 with `&&` and `||` to combine comparison conditions.
• You use `if` expressions to make simple decisions based on a condition, and return a value.
• You use `else` and `else-if` within an `if` expression to extend the decision-making beyond a single condition.
• You can use a single line `if-else` expression to make your code more clear and concise.
• Short circuiting ensures that only the minimal required parts of a Boolean expression are evaluated.
• 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.

## Where to go from here?

Apps very rarely run all the way through the same way every time; depending on what data comes in from the internet or from user input, your code will need to make decisions on which path to take. With `if` and `else`, you can have your code make decisions on what to do based on some condition.

In the next chapter, you’ll see how to use more advanced control flow statements. This will involve more loops like the `while` loop you saw in this chapter, and a new construct called the `when` expression.

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.

Have feedback to share about the online reading experience? If you have feedback about the UI, UX, highlighting, or other features of our online readers, you can send them to the design team with the form below:

© 2021 Razeware LLC