Kotlin When: Build Smarter Conditional Flows Easily

The 'when' expression is one of Kotlin's most powerful features, designed to simplify condition handling with a clean and concise syntax. It replaces the traditional switch statement found in other languages like Java or C++, offering much more flexibility and ease of use. If you've ever struggled with writing multiple branches of conditional logic or keeping your code readable when handling multiple cases, Kotlin when expression is your new best friend.

In this blog, you'll learn the ins and outs of 'when' expressions, from their syntax to practical examples, and understand how they can replace complex if statements or traditional switch statements. Whether you're working with strings, ranges, or particular types, this blog will help you master Kotlin when for better and more readable code.

What is Kotlin ‘When’ Expression?

At its core, the 'when' expression in Kotlin is a replacement for the switch statement found in other languages. Unlike a switch statement, the 'when' expression is more flexible, supports complex expressions, and can be used as both a statement and an expression.

Here’s an example of a simple 'when' expression:

Copy
fun main() {
    val day = 5
    val result = when (day) {
        1 -> "Monday"
        2 -> "Tuesday"
        3 -> "Wednesday"
        4 -> "Thursday"
        5 -> "Friday"
        6, 7 -> "Weekend" // Combining multiple values
        else -> "Invalid day"
    }
    println(result)
}

Key Features of Kotlin 'when' Expression

1. Flexibility: You can compare a variable against constants, ranges, or even boolean expressions.

2. Exhaustive: When used as an expression, all possible cases must be covered, including the else branch.

3. Syntactic Sugar: Simplifies complex conditional logic into readable and compact code.

4. Multiple Conditions: You can handle multiple conditions in a single branch using commas.

Kotlin 'when' Expression vs. 'when' Statement

While a 'when' expression returns a value, a 'when' statement is used to execute code without returning a result. Consider the difference:

'when' as an Expression

The 'when' expression is assigned to a variable, ensuring it evaluates to a value.

Copy
fun main() {
    val number = 10
    val result = when {
        number < 0 -> "Negative"
        number == 0 -> "Zero"
        else -> "Positive"
    }
    println(result) // Output: Positive
}

'when' as a Statement

Here, you use 'when' to execute specific block of code without assigning a value.

Copy
fun main() {
    val number = 10
    when {
        number < 0 -> println("Number is Negative")
        number == 0 -> println("Number is Zero")
        else -> println("Number is Positive")
    }
}

Anatomy of a 'when' Expression

To master the 'when' expression, it’s important to understand its key components:

1. Subject: The variable or expression being evaluated.

2. Branch Conditions: The conditions to match against the subject.

3. Branches: The block of code executed when a branch matches.

4. Else Branch: A mandatory fallback for unmatched cases when used as an expression.

Here’s an example demonstrating the anatomy:

Using the ‘Else’ Branch

The else branch ensures that your 'when' expression is exhaustive. Without it, Kotlin compiler throws an error if all possible cases aren’t handled. For instance:

Advanced Topics in Kotlin 'when'

Matching with the in Operator and Range

The in operator is a game-changer when dealing with ranges. You can define branch conditions for values falling within specific ranges:

Comparing Types

With 'when', you can also handle conditions based on the type of a variable:

Handling Multiple Conditions

Using commas, you can handle multiple conditions in a single branch, improving readability:

Kotlin 'when' vs. ‘Switch’ Statements

Unlike traditional switch statements in Java, Kotlin’s 'when' expression is much more versatile:

• Supports ranges and type checking.

• Allows you to use complex boolean expressions.

• Provides exhaustive checks when used as an expression.

For example, here’s how a typical switch statement compares to Kotlin's when:

Switch Statement in Java:

Kotlin 'when' Expression:

Best Practices for Using Kotlin 'when'

1. Use Exhaustive Conditions: Always include an else branch when the 'when' expression must return a value.x

2. Avoid Redundancy: Group multiple conditions using commas or ranges.

3. Keep It Readable: Avoid writing overly complex expressions within branches.

4. Prefer 'when' Over if Expression: When handling multiple branches, 'when' is cleaner and easier to maintain.

Final Notes!

Kotlin 'when' expression is a powerful tool that can simplify your conditional logic. Whether you’re working with ranges, strings, or types, it provides a readable and flexible way to handle multiple branches of logic. Unlike traditional switch statements, 'when' expressions in Kotlin are more expressive and concise.

By mastering ‘when’, you’ll write cleaner, more efficient code that is easier to maintain. So the next time you face a decision-making scenario in your code, let Kotlin 'when' be your go-to choice! Happy coding!

fun main() {
    val grade = 85
    when {
        grade >= 90 -> println("A")
        grade >= 80 -> println("B")
        grade >= 70 -> println("C")
        else -> println("Fail")
    }
}

fun main() {
    val animal = "Dog"
    val sound = when (animal) {
        "Cat" -> "Meow"
        "Dog" -> "Bark"
        "Cow" -> "Moo"
        else -> "Unknown Sound"
    }
    println(sound) // Output: Bark
}

fun main() {
    val age = 25
    val category = when (age) {
        in 0..12 -> "Child"
        in 13..19 -> "Teenager"
        in 20..59 -> "Adult"
        else -> "Senior"
    }
    println(category) // Output: Adult
}

fun main() {
    val obj: Any = "Kotlin"
    when (obj) {
        is String -> println("It's a String")
        is Int -> println("It's an Int")
        else -> println("Unknown Type")
    }
}

fun main() {
    val char = 'A'
    when (char) {
        'A', 'E', 'I', 'O', 'U' -> println("Vowel")
        else -> println("Consonant")
    }
}

switch (day) {
    case 1: return "Monday";
    case 2: return "Tuesday";
    default: return "Invalid day";
}

val result = when (day) {
    1 -> "Monday"
    2 -> "Tuesday"
    else -> "Invalid day"
}