Curso Kotlin | #10. Condicional IF
Tags: spanish, kotlin, tutorial, programming
Published: 2022-12-15 12:06:28

Bienvenido/a a otro capítulo del Curso de Kotlin! Podés consultar el curso completo desde [este link](https://github.com/maxwellnewage/kotlin-course) que te dejo acá. Podés seguirme por [LinkedIn](https://www.linkedin.com/in/maximilianoburgos/) o [Twitter](https://twitter.com/maxwellnewage) si querés estar al tanto de las próximas publicaciones.

Las estructuras condicionales nacen justo después de que se descubriera el fuego, con el primer ser que descubrió que se quemaba si tocaba ese nuevo descubrimiento. Me gusta pensar que mucha gente va a tomar esta frase como un razonamiento veraz e irrefutable.

Debo confesar que me costó horrores explicar los tópicos anteriores sin poder hacer referencias constantes a este. Muchos cursos y tutoriales lo han intentado, pero siempre se cruza el “vemos este IF ahora, pero luego será explicado en detalle”. Me siento orgulloso de haberte llevado por el sendero limpio del aprendizaje, dame ese premio Nobel del Aprendizaje.

Igualmente, antes de meternos de lleno con este tema, me gustaría que leas otro [artículo](https://dev.to/maxwellnewage/como-aprender-a-programar-desde-cero-n92) que va a complementar todo lo que veremos sobre condicionales.

Te recomiendo que leas especialmente el apartado de Diagramas de Flujo.

## Condicional IF
Usemos el ejemplo de la lotería que venimos desarrollando desde el apartado anterior. Imagina que quieres pedirle al usuario que elija un número de los ofrecidos anteriormente:

```kotlin
val numbers = arrayOf(1, 4, 6, 9, 15, 30, 45, 60, 78, 90)
println("Elije un numero de los siguientes: ${numbers.contentToString()}")
val selectedNum = readLine()
numbers.shuffle()
```

Si no comprendes algo de este código, deberías ver la clase anterior.

Declaramos un arreglo de numeros, los imprimimos, luego pedimos que escriba uno y mezclamos el array para generar un valor aleatorio. Ahora debemos preguntar si el valor elegido es el mismo que el primer indice numbers; en pocas palabras, si ganamos:

```kotlin
numbers.shuffle()

if(selectedNum == numbers[0] {
  println("Has ganado!")
}
```

Antes de entender el error, estudiemos la estructura: IF nos permite evaluar una expresión. Esto es lo que representa el contenido entre paréntesis. El signo “==” representa igualdad, en la teoría los llamamos “operador racional”. Estamos preguntando si selectedNum es igual al primer valor del arreglo numbers. Luego entre llaves tenemos el cuerpo de nuestra condicion, o sea lo que ocurrirá cuando ésta se cumpla. Entendido esto, vamos al error:

![Kotlin Error](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/vwu81e7mz8t3y7hqqua6.png)

Traducción: no puedo comparar la igualdad de un tipo String a un Int. Esto ocurre porque el método readLine() nos devuelve una cadena, por lo tanto deberíamos convertirlo:

```kotlin
if(selectedNum?.toInt() == numbers[0]){
    println("Has ganado!")
}
```

Con el método toInt(), visto en [otro capítulo](https://dev.to/maxwellnewage/curso-kotlin-4-variables-y-tipos-de-datos-17i7), convertimos nuestro String a entero. Recordemos que necesitamos usar el signo “?” porque estamos hablando de una variable nullable.

Este código va a funcionar bien. El problema es que solo nos va a informar una salida cuando ganemos. Queremos también devolver una condicion de derrota:

```kotlin
if(selectedNum?.toInt() != numbers[0]){
    println("Has perdido! El numero era ${numbers[0]}")
}
```

Aquí podemos observar otro operador racional, el cual significa lo opuesto al anterior. Cuando usamos “!=”, estamos diciendo que algo es distinto o diferente de otra cosa. Ahora tenemos dos condicionales IF, los cuales evaluan la victoria y la derrota. Pero vamos a implementar algo más práctico:

```kotlin
if(selectedNum?.toInt() == numbers[0]){
    println("Has ganado!")
} else {
    println("Has perdido! El numero era ${numbers[0]}")
}
```

En vez de tener dos IF, podemos utilizar la sentencia “else”, la cual justamente evalúa la condición contraria. En una traducción real, sería algo como: Si yo hago esto, pasa lo siguiente, si no, pasa lo contrario. Si mi número coincide con el número de la lotería, he ganado, si no, he perdido.

Si recuerdan la clase anterior, consideramos que también podían existir dos números ganadores. Esto lo podemos aplicar también con condicionales:

```kotlin
if(selectedNum?.toInt() == numbers[0] || selectedNum?.toInt() == numbers[1]){
    println("Has ganado!")
} else {
    println("Has perdido! El numero era ${numbers[0]}")
}
```

Te doy la bienvenida al mundo de los operadores lógicos. El operador “||”, también llamado OR, evalúa si en una expresión se cumplen dos o más condiciones. En este caso si el número que elegimos es igual a la primera o segunda posición de nuestro array. También tenemos el operador “&&”, también llamado AND, el cual evalúa que se cumplan todas las condiciones al mismo tiempo. Mucha gente se confunde pensando que si un valor puede tomar distintos caminos (como en este caso) deberíamos usar el AND, pero cuando lo implementan se dan cuenta de que la condición nunca se cumple porque en realidad estan evaluando que ese valor sea dos cosas distintas a la vez. Si implementáramos AND en este código, siempre caería en el else.

Vayamos un poco más a fondo: Imaginemos que queremos devolver resultados distintos si elige un número o el otro.

```kotlin
if(selectedNum?.toInt() == numbers[0]) {
    println("Has ganado el primer lugar!")
} else if(selectedNum?.toInt() == numbers[1]){
    println("Has ganado el segundo lugar!")
} else {
    println("Has perdido! El numero era ${numbers[0]}")
}
```

Si queremos evaluar condiciones que nos van a llevar a distintos caminos, podemos usar “else if”, el famoso “sino si”. Podemos usar tantos como queramos, pero si hay demasiadas condiciones para un mismo valor, lo ideal sería usar [when](https://kotlinlang.org/docs/control-flow.html#when-expression), el cual lo explicaremos en la siguiente clase.

## Conclusiones
Los condicionales definieron el mundo de la programación y la electrónica desde sus cimientos. Si les interesa profundizar más en este tema, les recomiendo que busquen acerca de compuertas lógicas. Es un tópico visto en cualquier carrera de sistemas en la universidad, y la vez es la base de la toma de desición de cualquier algoritmo existente. En cuanto a Kotlin, seguiremos profundizando este tema en las siguientes clases.