Kotlin When Expression: A Comprehensive Guide

Introduction

The Kotlin When expression is a powerful and versatile feature of the Kotlin programming language. Acting as a replacement for the traditional switch statement in other languages, when provides a cleaner and more concise way to handle control flow in your applications. Whether you're a beginner or an experienced developer, understanding the Kotlin When expression is crucial for writing efficient and readable code.

What Is the Kotlin When Expression?

The Kotlin When expression is a control flow structure used to execute a block of code based on specific conditions. It evaluates each condition sequentially and executes the block of code for the first condition that is satisfied. Unlike the switch statement, when in Kotlin supports complex expressions, ranges, and type checks.

Basic Syntax of the When Expression

📄

when (expression) {
    value1 -> // Block of code for value1
    value2 -> // Block of code for value2
    else -> // Default block if no conditions are met
}

Here, expression is evaluated, and the corresponding block of code is executed for the matching condition.

Using When Expression in Kotlin

1. Handling Multiple Conditions

The when expression can be used to match multiple conditions:

📄

val day = "Monday"
val result = when (day) {
    "Monday", "Tuesday", "Wednesday" -> "Weekday"
    "Saturday", "Sunday" -> "Weekend"
    else -> "Invalid day"
}
println(result)

2. Using Ranges

You can check if a value lies within a specific range using when:

📄

val number = 15
val rangeCheck = when (number) {
    in 1..10 -> "Number is between 1 and 10"
    in 11..20 -> "Number is between 11 and 20"
    else -> "Number is out of range"
}
println(rangeCheck)

3. Type Checking

The is operator can be used in a when expression for type checking:

📄
fun checkType(obj: Any) {
    when (obj) {
        is String -> println("It's a String with length ${obj.length}")
        is Int -> println("It's an Integer with value $obj")
        else -> println("Unknown type")
    }
}

4. Expression or Statement

The when expression can return a value directly:

📄

val age = 25
val category = when {
    age < 18 -> "Minor"
    age in 18..60 -> "Adult"
    else -> "Senior"
}
println("You are categorized as $category")

Advanced Features of the When Expression

1. Smart Casts

Kotlin's type-checking in when supports smart casts:

📄

fun handleInput(input: Any) {
    when (input) {
        is String -> println("String length: ${input.length}")
        is Int -> println("Doubled value: ${input * 2}")
    }
}

2. Using Functions in Conditions

Functions can be used as conditions in a when expression:

📄

fun isEven(num: Int): Boolean = num % 2 == 0

val num = 8
val result = when {
    isEven(num) -> "$num is even"
    else -> "$num is odd"
}
println(result)

3. Exhaustive When

For enums and sealed classes, when can be exhaustive, ensuring all possible cases are covered:

📄

enum class Color {
    RED, GREEN, BLUE
}

fun colorInfo(color: Color): String = when (color) {
    Color.RED -> "Color is Red"
    Color.GREEN -> "Color is Green"
    Color.BLUE -> "Color is Blue"
}

Best Practices for Using When Expression

• Use else as a fallback to handle unexpected cases.
• Leverage ranges and patterns for concise conditions.
• Ensure when is exhaustive when dealing with enums or sealed classes.
• Organize complex conditions into separate functions for clarity.

Conclusion

The Kotlin When expression is a powerful tool for handling control flow efficiently and elegantly. Its versatility, from simple condition matching to advanced pattern handling, makes it an indispensable part of Kotlin programming. By mastering this feature, you can write cleaner, more maintainable code in your Kotlin projects.

FAQs

1. What is the difference between when and switch in Kotlin?

Unlike switch, Kotlin's when supports multiple conditions, ranges, type checking, and can be used as an expression to return values.

2. Can I use when without an argument?

Yes, you can use when without an argument to evaluate conditions directly:

📄

when {
    condition1 -> println("Condition 1 met")
    condition2 -> println("Condition 2 met")
}

3. How do I handle enums in a when expression?

Use when with enums to create exhaustive conditions:

📄

enum class Status { SUCCESS, FAILURE, UNKNOWN }
val statusMessage = when (status) {
    Status.SUCCESS -> "Operation successful"
    Status.FAILURE -> "Operation failed"
    Status.UNKNOWN -> "Unknown status"
}

4. Can I nest when expressions?

Yes, you can nest when expressions, but ensure readability:

📄

when (outerCondition) {
    condition1 -> when (innerCondition) {
        subCondition1 -> println("Nested condition met")
    }
}

5. How does when differ from if-else in Kotlin?

When is more concise and readable for multiple conditions compared to if-else, especially when dealing with complex scenarios.