Kotlin when Expression

In Kotlin, the when expression is more than just a simple switch-case.

It's a flexible control flow tool that evaluates a given section of code among multiple alternatives, enhancing code readability and maintainability.

By finding similarities with real-life decision-making, you can imagine when as a branching path in a forest trail, choosing directions based on specific conditions or "cases."

For more details, you can explore Kotlin's official documentation on control flow.

The Basics of `when`

Simple Expression

The core syntax of the when expression is intuitive. Let's start with a basic example:

val x = 3
val message = when (x) {
    1 -> "One"
    2 -> "Two"
    3 -> "Three"
    else -> "Unknown"
}

Explanation:

Expression Initialization: We declare a variable x and assign it the value 3.
When Clause: The when keyword starts the expression by checking the value of x.
Cases: Each number (1, 2, 3) followed by -> represents a possible case for x.
Default Case: The else branch acts as a fallback option if none of the previous cases match.

The expression evaluates to "Three" because x is set to 3.

Learn more about Kotlin's when expression from GeeksforGeeks.

Combining Conditions

Kotlin lets you combine conditions in a single case, making the when expression even more versatile:

val status = when (x) {
    1, 3, 5 -> "Odd"
    2, 4, 6 -> "Even"
    else -> "Unknown"
}

Explanation:

Multiple Conditions: The commas allow grouping of conditions (e.g., 1, 3, 5 for "Odd").
Efficient Check: This means if x equals any of the numbers, the corresponding branch executes.

Explore more at Baeldung's guide on Kotlin's when block.

Versatility in Kotlin `when` Expression

Using `when` Without An Argument

A when expression can be used without an argument, effectively serving as an extended if-else logic:

val message = when {
    x % 2 == 0 -> "Even"
    x % 2 != 0 -> "Odd"
    else -> "Unknown"
}

Explanation:

No Argument: The conditions directly follow the when keyword, evaluating boolean results.
Logical Flow: This scenario provides more control for intricate logic pathways, similar to life exploring different labyrinths based on unique rules.

Checking Value Types

In Kotlin, when is not limited to numeric values. It can also evaluate object types:

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

Explanation:

Type Checking: The is keyword checks the object type within the when block.
Polymorphic Capability: It's like analyzing different plants in a garden by their characteristics.

Visit Programiz for more examples of Kotlin when expression.

Practical Applications of `when`

Simplifying Code

When coding, simplicity often translates to efficiency. By replacing nested if-else chains with when, you streamline logical operations:

fun translateNumberToWord(num: Int) = when (num) {
    0 -> "Zero"
    1 -> "One"
    2 -> "Two"
    else -> "Many"
}

Enhancing Maintainability

Code that looks clean is easier to maintain. The when expression allows for future expansion by adding new cases with minimal disruptions:

Easily Extendable: New cases can be integrated without altering the existing structure.
Readable Format: Just like a well-organized library, your code becomes more navigable with clear sections.

Mastering the `when` Expression

In the ever-evolving landscape of programming, the Kotlin when expression stands out as an efficient tool to make your code not only functional but also elegant.

It's like having a Swiss Army knife right at your fingertips, ready to handle an array of logical cases with grace.

Embrace when in your Kotlin projects, and watch how it can redefine your coding experience, enhancing both clarity and functionality.

For further reading, check Kotlin's language specification to deepen your understanding of expressions.

The Code

Search This Blog