Using "when" expression in Kotlin: The "switch" with super powers (KAD 13)

The switch expression in Java, and especially in Java 6, are extremely limited. Apart from a very short amount of types, it can not be used for anything else.

But, however, when expressions in Kotlin can do everything you can do with a switch and much more.

Actually, with when you can substitute the most complex if/else you can have in your code.

Would you like to start today to take the next step? I recommend that you sign up to my free training here.

when expression in Kotlin

For starters, you can use it as a regular switch. Imagine that, for example, you have a view and want to display a toast based on its visibility.

You can do:

when(view.visibility){
    View.VISIBLE -> toast("visible")
    View.INVISIBLE -> toast("invisible")
    else -> toast("gone")
}

In when, else is the same as default for switch. You give a solution for the rest of the alternatives you’re not covering in the expression.

But when has some other extra features that make it really powerful:

Auto-casting

If you check something in the left side (for instance, that an object is an instance of an specific type), you’ll get the cast in the right side for free:

when (view) {
    is TextView -> toast(view.text)
    is RecyclerView -> toast("Item count = ${view.adapter.itemCount}")
    is SearchView -> toast("Current query: ${view.query}")
    else -> toast("View type not supported")
}

Besides checking a type, when can check for instance if an element is inside a range or a list, by using the reserved word in.

when without arguments

With this option, we can check basically anything we want in the left side of the when condition.

val res = when {
    x in 1..10 -> "cheap"
    s.contains("hello") -> "it's a welcome!"
    v is ViewGroup -> "child count: ${v.getChildCount()}"
    else -> ""
}

As when is an expression, it can return a value that can be stored in a variable.

An example applied to Android

The above examples are very simple and far from having any real use.

But an example that I like a lot is to consume the answer in an onOptionsItemSelected().

override fun onOptionsItemSelected(item: MenuItem) = when (item.itemId) {
    R.id.home -> consume { navigateToHome() }
    R.id.search -> consume { MenuItemCompat.expandActionView(item) }
    R.id.settings -> consume { navigateToSettings() }
    else -> super.onOptionsItemSelected(item)
}

The consume function is a very simple one that executes the operation and returns true. I find it very useful for the methods of the Android framework that need to indicate if they have consumed the result.

The code involved is very simple:

inline fun consume(f: () -> Unit): Boolean {
    f()
    return true
}

Conclusion

With the when expression you can make it really easy to create code where you can specify the behaviour through several paths, and where the original Java switch lack some power.

And if you want to learn how to use Kotlin to develop your own Android Apps, I recommend you take a look at my free training. Reserve your place!