Control Flow

Introduction

Control flow determines which code runs, and how many times. Kotlin's control-flow constructs will look familiar if you know any C-family language, but with one major twist: `if` and `when` are expressions in Kotlin, meaning they can directly produce and return a value, not just branch execution.

This lesson covers `if` as an expression, the powerful `when` construct that replaces `switch`, ranges, and all of Kotlin's looping constructs.

if as an Expression

In Kotlin, `if` can be used the traditional way as a statement, or as an expression that evaluates to a value — eliminating the need for a separate ternary operator, which Kotlin deliberately does not have.

fun main() {
    val age = 20

    // Traditional statement form
    if (age >= 18) {
        println("Adult")
    } else {
        println("Minor")
    }

    // Expression form — if directly produces a value
    val status = if (age >= 18) "Adult" else "Minor"
    println(status)
}

when Instead of switch

`when` is Kotlin's replacement for Java's `switch` statement, and it is dramatically more powerful. It supports arbitrary expressions in each branch (not just constants), range checks, type checks, and — like `if` — can be used as an expression that returns a value.

fun describe(x: Any): String = when (x) {
    1 -> "One"
    2, 3 -> "Two or three"
    in 4..10 -> "Between four and ten"
    is String -> "A string of length ${x.length}"
    else -> "Something else"
}

fun main() {
    println(describe(1))
    println(describe(7))
    println(describe("Kotlin"))
    println(describe(99.9))
}

Ranges

Kotlin has a built-in range type, created with `..`, that represents a sequence of values. Ranges are used constantly with `when`, `for` loops, and membership checks with `in`.

fun main() {
    val r = 1..5             // 1, 2, 3, 4, 5
    println(3 in r)           // true
    println(9 in r)           // false

    val countdown = 5 downTo 1        // 5, 4, 3, 2, 1
    val evens = 0..10 step 2           // 0, 2, 4, 6, 8, 10
    val exclusive = 1 until 5          // 1, 2, 3, 4 (5 excluded)

    println(evens.toList())
}

for Loops

Kotlin's `for` loop always iterates over something that provides an iterator — most commonly a range, a collection, or a string's characters. There is no traditional C-style `for (int i = 0; i < n; i++)` in Kotlin; ranges cover that use case instead.

fun main() {
    for (i in 1..5) {
        print("$i ")
    }
    println()

    val languages = listOf("Kotlin", "Java", "Swift")
    for (lang in languages) {
        println("Language: $lang")
    }

    for ((index, lang) in languages.withIndex()) {
        println("$index: $lang")
    }
}

while and do-while Loops

`while` and `do-while` behave exactly as they do in Java and C: `while` checks its condition before the first iteration, and `do-while` guarantees the body runs at least once before checking.

fun main() {
    var count = 0
    while (count < 3) {
        println("while: $count")
        count++
    }

    var attempts = 0
    do {
        println("do-while: $attempts")
        attempts++
    } while (attempts < 3)
}

Labeled break and continue

By default, `break` and `continue` only affect the nearest enclosing loop. Kotlin lets you label a loop and target it explicitly, which is especially useful for breaking out of nested loops in one step.

fun main() {
    outer@ for (i in 1..3) {
        for (j in 1..3) {
            if (j == 2) continue@outer
            println("i=$i, j=$j")
        }
    }
}

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

You can now branch and loop through Kotlin code idiomatically, using if and when as expressions and ranges for iteration. Next, you'll learn how to organize logic into reusable functions.