How to Use the "When" Expression In Kotlin?

12 minutes read

The "when" expression is Kotlin's version of a switch statement. It allows you to execute different blocks of code based on the value of an expression. Here's how you can use it:

  1. Start by typing the keyword "when" followed by an opening parenthesis "(".
  2. Inside the parentheses, provide the expression whose value you want to evaluate.
  3. After the expression, type a closing parenthesis ")" followed by an opening brace "{" to start the code block for the "when" expression.
  4. Inside the code block, you can define different cases using the "->" symbol.
  5. Each case consists of a value or a condition followed by an arrow "->" and a block of code to execute if that case matches the expression.
  6. You can have multiple cases separated by commas.
  7. You can also provide a default case using the keyword "else" followed by an arrow "->" and the code to execute if none of the cases match.
  8. Close the "when" expression code block with a closing brace "}".


Example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
fun main() {
    val number = 5
    when (number) {
        1 -> println("One")
        2 -> println("Two")
        3, 4 -> println("Three or Four")
        in 5..10 -> println("Between five and ten")
        else -> println("Other number")
    }
}


In this example, the "when" expression evaluates the value of the variable "number". It checks various cases and executes the corresponding block of code. If "number" is 1, it prints "One". If it's 2, it prints "Two". If it's 3 or 4, it prints "Three or Four". If it's between 5 and 10 (inclusive), it prints "Between five and ten". If none of the above cases match, it prints "Other number".


This is an overview of how to use the "when" expression in Kotlin. It provides a powerful and concise way to handle multiple conditions and execute different code blocks based on those conditions.

Best Kotlin Books to Read in 2024

1
Atomic Kotlin

Rating is 5 out of 5

Atomic Kotlin

2
Kotlin in Action

Rating is 4.9 out of 5

Kotlin in Action

3
Head First Kotlin: A Brain-Friendly Guide

Rating is 4.8 out of 5

Head First Kotlin: A Brain-Friendly Guide

4
Kotlin Programming: The Big Nerd Ranch Guide (Big Nerd Ranch Guides)

Rating is 4.7 out of 5

Kotlin Programming: The Big Nerd Ranch Guide (Big Nerd Ranch Guides)

5
Kotlin Cookbook: A Problem-Focused Approach

Rating is 4.6 out of 5

Kotlin Cookbook: A Problem-Focused Approach

6
Java to Kotlin: A Refactoring Guidebook

Rating is 4.5 out of 5

Java to Kotlin: A Refactoring Guidebook

7
Programming Kotlin: Create Elegant, Expressive, and Performant JVM and Android Applications

Rating is 4.4 out of 5

Programming Kotlin: Create Elegant, Expressive, and Performant JVM and Android Applications

8
Advanced Kotlin (Kotlin for Developers Book 4)

Rating is 4.3 out of 5

Advanced Kotlin (Kotlin for Developers Book 4)


How to define multiple branches in a "when" expression in Kotlin?

In Kotlin, you can define multiple branches in a when expression by separating them with a comma ,. Here's an example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
when (variable) {
    value1 -> {
        // code for value1 branch
    }
    value2, value3 -> {
        // code for value2 and value3 branches
    }
    value4 -> {
        // code for value4 branch
    }
    else -> {
        // code for all other cases
    }
}


In the example above, the when expression takes a variable and checks it against different values. If variable matches value1, the code in the value1 branch will be executed. If variable matches either value2 or value3, the code in the value2 and value3 branch will be executed. Similarly, if variable matches value4, the code in the value4 branch will be executed. If none of the defined branches match, the code in the else branch will be executed.


What is the purpose of the "when" expression in Kotlin?

The "when" expression in Kotlin is used to replace a series of if-else if statements. It allows you to check multiple conditions and perform different actions based on the condition that matches.


The purpose of the "when" expression is to simplify and make code more readable when dealing with multiple conditional cases. It makes it easier to handle situations where there are many possible options to check.


It can be used with various data types such as numbers, characters, strings, and even with more complex objects. The "when" expression provides a more concise and efficient way to handle multiple conditions compared to traditional if-else if statements.


What is the performance impact of using the "when" expression in Kotlin?

The "when" expression in Kotlin does not have a significant performance impact compared to other control flow statements like "if" or "switch". It is designed to be efficient and optimized by the Kotlin compiler.


The "when" expression in Kotlin compiles to a sequence of "if-else" statements or a lookup table (depending on the number of cases), making it efficient and avoiding unnecessary branching or evaluations. It is similar to the "switch" statement in other languages but provides more flexibility and powerful matching capabilities.


However, it is important to note that the performance impact of using "when" in your specific code depends on the complexity of your logic and the number of cases. In general, using "when" is not likely to be a major bottleneck in terms of performance, but if you have a large number of cases or complex conditions, it may be worth optimizing or refactoring your code for better clarity and efficiency.


How to use the "when" expression for type checks in Kotlin?

In Kotlin, the when expression is a powerful replacement for the traditional switch statement. It can be used for conditional branching based on different values or conditions, including type checks. To use the when expression for type checks, follow these steps:

  1. Start by writing the when keyword and providing the value you want to check against type.
  2. Use the is keyword followed by the type you want to check for. This checks if the value is an instance of the specified type.
  3. Specify the code that will be executed if the type check passes.
  4. Repeat steps 2 and 3 for each additional type check.
  5. Use the else keyword followed by the code that will be executed if none of the type checks pass.


Here's an example that demonstrates the usage of the when expression for type checks:

1
2
3
4
5
6
7
8
fun printType(value: Any) {
    when (value) {
        is String -> println("Value is of type String")
        is Int -> println("Value is of type Int")
        is Double -> println("Value is of type Double")
        else -> println("Unknown type")
    }
}


In this example, the printType function takes an argument of type Any and uses when to check for various types (String, Int, and Double).


You can call this function with different values to see the type check in action:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
printType("Hello")
// Output: Value is of type String

printType(42)
// Output: Value is of type Int

printType(3.14)
// Output: Value is of type Double

printType(true)
// Output: Unknown type


The when expression makes it easy to perform type checks in Kotlin, allowing you to execute appropriate code paths based on the detected type.


How to use the "when" expression to handle different types of exceptions in Kotlin?

In Kotlin, you can use the when expression to handle different types of exceptions. The when expression allows you to match on different cases and execute corresponding code blocks based on the matched case.


Here's how you can use the when expression to handle different types of exceptions in Kotlin:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
try {
    // Code that may throw exceptions
} catch (e: Exception) {
    when (e) {
        is IOException -> {
            // Handle IOException
        }
        is FileNotFoundException -> {
            // Handle FileNotFoundException
        }
        is IllegalArgumentException -> {
            // Handle IllegalArgumentException
        }
        else -> {
            // Handle other types of exceptions
        }
    }
}


In the catch block, you can use the when expression with the is operator to check the type of the exception (e) and execute the corresponding code block.


If the exception is of type IOException, the code inside the corresponding branch will execute. Similarly, for FileNotFoundException, IllegalArgumentException, and other types of exceptions, you can have separate branches to handle different cases. The else branch is used for handling exceptions that don't match any of the specified cases.


You can also use the when expression without an argument to handle exceptions in a concise manner:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
try {
    // Code that may throw exceptions
} catch (e: Exception) {
    when {
        e is IOException -> {
            // Handle IOException
        }
        e is FileNotFoundException -> {
            // Handle FileNotFoundException
        }
        e is IllegalArgumentException -> {
            // Handle IllegalArgumentException
        }
        else -> {
            // Handle other types of exceptions
        }
    }
}


In this case, the code inside the branch will execute if the corresponding condition evaluates to true.


Using the when expression to handle different types of exceptions in Kotlin allows for clear and concise exception handling based on the type of the exception.


What is the difference between "when" expression and "if-else" statement in Kotlin?

The main difference between a "when" expression and an "if-else" statement in Kotlin lies in their syntax and usage.

  1. Syntax:
  • "When" expression:
1
2
3
4
5
when (variable) {
    value1 -> statement1
    value2 -> statement2
    else -> statement3
}


  • "If-else" statement:
1
2
3
4
5
6
7
if (condition) {
    statement1
} else if (condition2) {
    statement2
} else {
    statement3
}


  1. Usage:
  • "When" expression: It is mainly used for multiple conditions or matching a variable against different values. It provides a more concise and readable way to handle multiple branches compared to nested if-else statements.
  • "If-else" statement: It is mainly used for conditional execution based on a single condition. It is useful when there is a need to execute different statements based on the outcome of a single condition.
  1. Checking conditions vs. matching values:
  • "When" expression: It allows you to check various conditions such as checking types, ranges, and other expressions. It provides the ability to match values against multiple cases.
  • "If-else" statement: It primarily focuses on checking boolean conditions. It evaluates a condition to either true or false and executes the statements accordingly.


In summary, "when" expressions are better suited for scenarios where you have multiple conditions to evaluate whereas "if-else" statements are more appropriate when you have a straightforward condition to check.

Facebook Twitter LinkedIn Whatsapp Pocket

Related Posts:

The Kotlin Standard Library functions are a set of utility functions that come built-in with the Kotlin programming language. These functions provide convenient ways to perform common tasks when working with different types of data.To use the Kotlin Standard L...
The "case" expression is a powerful feature in Haskell that allows you to pattern match on the values of a variable. It is commonly used to perform different actions based on the input or handle different cases of a data type. The general structure of ...
The Android Kotlin Extensions, also known as KTX, is a library that provides a set of Kotlin extensions for Android development. It aims to simplify Android development by offering concise and idiomatic Kotlin code for common Android tasks.To use the Android K...