Los condicionales en Kotlin: if y when

▶

Los condicionales son un elemento fundamental en cualquier lenguaje de programación, nos permite realizar bifurcaciones en el código en base a una condición establecida en los mismos. En esta entrada veremos cómo emplear los condicionales if y when que viene siendo una variante del switch en Kotlin.

Condicionales if

El condicional if() es muy similar al empleado en cualquier otro lenguaje de programación como Java, PHP, JavaScript, etc.

val d: Int
val check = true

if (check) {
    d = 1
} else {
    d = 2
}

println(d)
// 1

Retorno de valores/variables en el condicional

En este pequeño ejemplo, comparamos la variable x al valor retornado por el condicional, que puede ser true o false dependiendo del valor que tenga la variable x en un momento dado (para el ejemplo h tendría el valor true); para emplear esta estructura debemos dejar el valor que queremos retornar (en este caso un booleano) al final de los condicionales (el if y el else, por supuesto, el condicional puede implementar cualquier otra lógica o serie de operaciones, pero los valores de retorno -los que queremos establecer en la variable asignada- deben estar establecidos al final del condicional).

Esto es una interesante funcionalidad que tiene Kotlin que permite reducir la cantidad de líneas de código cuando queremos expresar una jerarquía de condicionales, la redundancia en la asignación a variables finales y nos permite tener código más conciso y legible que se traduce en una mejor experiencia al momento de desarrollar nuestras aplicaciones, y por supuesto, prácticamente podemos emplear este esquema con cualquier otra estructura.

Los condicionales en Kotlin siguen la lógica tradicional, pero con una característica moderna muy potente: pueden retornar un valor. Esto es especialmente útil cuando trabajamos con nulabilidad o peticiones a una API.

Pero tiene un interesante añadido que permite indicar si la última expresión de un condicional es un valor, entonces podemos asignar dicho valor a alguna variable; es decir:

var x = 5
val h = if (x > 0) {
   // otras operaciones
    true
} else { 
   // otras operaciones
    false
}

Si necesitas asignar un valor a una constante (val) basándote en una condición (como si un usuario está autenticado para mostrar su lista de cursos), puedes hacerlo directamente. Al usar val, aseguras que esa propiedad no cambie durante la ejecución, manteniendo el código limpio y seguro desde el primer momento:

val resultado = if (usuarioAutenticado) {
    "Pool de cursos"
} else {
    "Valor por defecto"
}

El operador "Ternario" en Kotlin

En Kotlin no existe el operador ternario clásico (condicion ? true : false), pero se simula de una forma muy elegante usando if en una sola línea:

val mensaje = if (isLogged) "Bienvenido" else "Por favor, inicia sesión"

Verificar si una variable es nula: autocasteo

Un punto muy importante, es que aparte de las implementaciones que vimos anteriormente para emplear las propiedades de las variables de tipo NULLable o que puede ser nula en Kotlin mediante un condicional:

val str: String? = "Kotlin"
if (str != NULL) {
    println(str.length)
}

Recordemos que si una variable es declarada como NULLable, significa que puede ser nula en algún momento y por lo tanto obligatoriamente debemos emplear los operadores que empleamos en una anterior entrada para evitar referencias nulas, pero al realizar la verificación anterior, podemos saltarnos este paso de emplear los operadores, ya que el compilador de Kotlin hace un autocasteo a la variable NULLable que estemos comprobando y de esta manera podemos emplear cualquier propiedad sin la necesidad de estos operadores.

El bloque when: Un Switch con esteroides

Otra expresión que podemos emplear para cuando tenemos muchos condicionales es la expresión when que viene siendo el equivalente de la expresión switch de otros lenguajes de programación pero también potenciada.

El when evalúa un objeto y ejecuta la rama que coincida. El caso else actúa como el default del switch tradicional:

val objecto = "Hello"
when (objeto) {
   "1" -> println("Es uno")
   "Hello" -> println("Es un saludo")
   else -> println("No coincide")
}

Ejecución Implícita (Break)

En Kotlin, el when tiene un "break" implícito. Una vez que encuentra la primera coincidencia que sea verdadera, ejecuta su código y sale del bloque. No necesitas escribir break en cada caso.

Comparaciones de Rango y Tipos

Podemos expresar valores por rango:

when (x) {
    in 1..9 -> print("x es un número entero positivo de una cifra")
    else -> print("x no es un número entero positivo de una cifra")
}

Podemos emplear funciones para indicar el tipo de dato de la variable:

when (x) {
    is String -> print("x es un texto")
    else -> print("ninguno de los anteriores")
}

Características avanzadas del when

Emplear funciones propias o de alguna API:

Uso de funciones y lógica compleja

Puedes usar el resultado de una función dentro de las ramas del when. Además, si no le pasas un parámetro al when, este se comporta como una serie de bloques if-else if, lo que te permite colocar condiciones de comparación (>, <, !=) libremente.

fun mas_cinco(n: Int): Int {
   return n + 5
}

fun main() {
    val x = 10 // Supongamos que x es 10
    
    when (x) {
       in 1..9 -> println("x es de una cifra")
       
       // Esta condición se cumple si x es igual al resultado de la función
       // Si x fuera 0 y la función sumara 0, o si pasaras OTRO valor a la función:
       mas_cinco(10) -> println("x es 15 (porque 10 + 5 = 15)") 
       
       !in 10..20 -> println("x está fuera de rango")
       else -> println("ninguno de los anteriores")
    }
}

Indicar que un número sea par:

when (x){
    x.isEven() -> print("x es par")
    else -> print("x es impar")
}

O indicar que sea impar, negando la función anterior:

when (x){
    !x.isEven() -> print("x es par")
    else -> print("x es impar")
}

O empleando la función para indicar que el número sea impar:

when (x){
    x.isOdd() -> print("x es impar")
    else -> print("x es par")
}

Estos últimos ejemplos estamos empleando funciones de extensión para definir isOdd() y isEven() que será tema de otra entrada.

También como puedes ver en el código anterior, podemos emplear la palabra reservada else que funciona igual que el default en otros lenguajes de programación.

Podemos decidir no expresar el valor en cláusula when y en vez de esto expresarlo en cada uno de los casos.

when {
    x.isOdd() -> print("x is odd")
    x.isEven() -> print("x is even")
    else -> print("x is funny")
}

Realizar operaciones matemáticas:

when(x) {
    10 + 20 -> print("30")
    else -> print("Otro valor")
}

Que por supuesto estos valores pueden ser variables.

También podemos emplear el bloque definido del when para retornar un valor y este sea asignado a una variable, al igual que hicimos con el if anteriormente:

val r = when(x) {
    10 + 20 -> "30"
    else -> "Otro valor"
}

Podemos combinar todas estas opciones que vimos anteriormente como queramos, la idea es presentar algunos de los posibles escenarios para tener una idea más clara del funcionamiento de este poderoso condicional que podemos emplear en Kotlin.

Resumen

• if/Else: Se pueden usar como expresiones para asignar valores directamente.
• When: Es el reemplazo del switch. Es más limpio, permite usar rangos (in), evaluar funciones y no requiere break.
• Seguridad: Kotlin te obliga a respetar los tipos de datos en las comparaciones, lo que evita errores abstractos y hace el código más legible.

El siguiente paso que vamos a ver, es como usar las funciones en Kotlin.