Kotlin if and when

if (temperature > 25) {
    println("Shorts weather")
} else if (temperature > 15) {
    println("Bring a jumper")
} else {
    println("Coat on")
}

• The condition in brackets must be a Boolean.
• Kotlin checks each condition from top to bottom and runs only the first branch that's true.
• else runs when nothing else matched.
• With a single statement, the braces are optional, but adding them keeps code consistent and safe to extend.

Because if produces a value, you can assign its result directly:

val label = if (score >= 50) "Pass" else "Fail"
val max = if (a > b) a else b

When if is used as an expression, the else branch is required, so every possible case produces a value. In a block with several lines, the last expression in the block is the value:

val fee = if (isMember) {
    println("Member discount applied")
    5.0
} else {
    10.0
}

when compares a value against a list of branches:

when (day) {
    "Sat", "Sun" -> println("Weekend")
    "Fri" -> println("Almost there")
    else -> println("Weekday")
}

• Separate several values with commas.
• Use in for ranges: in 90..100 -> "A".
• Use is to check a type: is String -> ..., after which the value is smart cast.
• Branches don't fall through, so there's no break to forget.

Without an argument, each branch is a full condition, which neatly replaces an else if chain:

val advice = when {
    temp > 25 && sunny -> "Sun cream"
    temp > 25 -> "Stay cool"
    raining -> "Umbrella"
    else -> "Enjoy your day"
}

Like if, when can return a value. When it does, it must be exhaustive: every possible input must be handled, usually with else. For enums and sealed classes, the compiler can check you've covered every case without needing else, as the enums and sealed classes lesson shows.

Often the value you want to test is the result of a calculation, such as cleaned-up user input. You can compute it and give it a name right inside the brackets of when:

when (val cmd = readCommand().trim().lowercase()) {
    "start" -> println("Starting")
    "stop", "quit" -> println("Stopping")
    else -> println("Unknown command: $cmd")
}

The name cmd exists only inside the when, so it can't leak into the rest of the function and be used by mistake later. The value is computed once, even though several branches compare against it.

Branch conditions don't have to be literal values either. Any expression works, and Kotlin compares the subject with its result using ==:

fun shippingBand(country: String) = when (val code = country.uppercase()) {
    "GB" -> "Domestic"
    in setOf("FR", "DE", "ES") -> "Europe"
    else -> "International ($code)"
}

Here shippingBand("de") gives "Europe" and shippingBand("jp") gives "International (JP)". Notice how converting to upper case once, in the subject, means no branch has to worry about the user typing lower case.

You can flip in and is with an exclamation mark. Branches are still checked from top to bottom, so put the rejections first and let the happy path fall through to else:

fun check(x: Any) = when (x) {
    !is Int -> "not a number"
    !in 0..10 -> "out of range"
    else -> "ok"
}

check("a") gives "not a number", check(42) gives "out of range" and check(4) gives "ok". By the time the second branch runs, Kotlin already knows x is an Int, so the range check is allowed.

when also handles nullable values neatly. A null branch catches the missing case, and after it the value is smart cast to non-null:

val text = when (nickname) {
    null -> "missing"
    "" -> "empty"
    else -> "has ${nickname.length} letters"
}

This is often tidier than an if (nickname == null) ... else if (nickname.isEmpty()) chain, and it reads like a table of cases.