Condicionales

Hasta ahora hemos visto código que se ejecuta línea a línea, una detrás de otra. Pero a veces se hace necesario romper esa secuencia y crear ramas que nos permitan tomar diferentes caminos en el código dependiendo de ciertas condiciones.

Por ejemplo, imagina cómo podríamos hacer un programa que nos diga si un número es mayor o menor a diez. Si es mayor a diez debería imprimir una cosa, pero si es menor debería imprimir otra.

A este concepto se le conoce como condicionales y su sintaxis es la siguiente:

if <condición>
  # código que se ejecuta si se cumple la condición
end

Para probar los condicionales empieza creando un archivo llamado conditionals.rb con el siguiente contenido:

if true
  puts "Hola mundo"
end

Ejecútalo varias veces. En todas debería imprimir "Hola mundo":

$ ruby conditionals.rb
Hola mundo

Ahora probemos con una condición que siempre va a ser falsa.

if false
  puts "Hola mundo"
end

Ejecútalo. Esta vez nunca debería imprimir "Hola mundo", no importa cuantas veces lo ejecutes.

También podemos utilizar una expresión booleana en la condición. Por ejemplo:

if 1 == 1
  puts "Hola mundo"
end

El resultado al ejecutarlo debería ser:

$ ruby conditionals.rb
Hola mundo

Prueba ahora con las expresiones 1 == 2, 1 < 6 y 8 < 6 en la condición y fíjate que tenga sentido.

Ahora que ya sabes cómo funciona los condicionales (muchos los llamamos los ifs) crea un programa en un archivo llamado number.rb que le pida al usuario que ingrese un número e imprima "El número es menor a 10" solo si el número que ingresó el usuario es menor a 10:

print "Ingresa un número: "
num = gets.chomp.to_i

if num < 10
  puts "El número es menor a 10"
end

Si lo ejecutas e ingresas un número menor a 10 te debería salir lo siguiente:

$ ruby number.rb
Ingresa un número: 5
El número es menor a 10

Ahora modifica el programa para que imprima "El número es igual o mayor a 10" si el número que ingresó el usuario es igual o mayor a 10:

print "Ingresa un número: "
num = gets.chomp.to_i

if num < 10
  puts "El número es menor a 10"
end

if num >= 10
  puts "El número es igual o mayor a 10"
end

Ejecuta el programa e ingresa un número menor a 10, después un número mayor a 10, y por último 10. Verifica que el resultado sea el esperado.

De lo contrario (else)

Lo único que necesitas para hacer condicionales es el if. Pero existen dos atajos que te van a permitir escribir código más corto.

El primer atajo es el else, que significa "de lo contrario" en Inglés. El else nos permite definir el código que se debe ejecutar si el if no se cumple, es decir si la condición evalúa a falso. La sintaxis es la siguiente:

if <condicion>
  # código que se ejecuta si se cumple la condición
else
  # código que se ejecuta si NO se cumple la condición
end

Podemos modificar el programa anterior, que nos dice si el número almacenado en la variable num es menor a 10, o si es mayor o igual, con un else.

print "Ingresa un número: "
num = gets.chomp.to_i

if num < 10
  puts "El número es menor a 10"
else
  puts "El número es igual o mayor a 10"
end

Más corto y si lo ejecutas debería funcionar igual.

Anidando condicionales

Ahora imagina que queremos modificar este programa para que imprima:

"El número es menor a 10" si el número es menor a 10.
"El número es mayor a 10" si el número es mayor a 10.
"El número es igual a 10" si el número es igual a 10.

En Ruby (y en la mayoría de lenguajes de programación) es posible anidar condicionales, así que una posible solución sería la siguiente:

print "Ingresa un número: "
num = gets.chomp.to_i

if num < 10
  puts "El número es menor a 10"
else
  if num > 10
    puts "El número es mayor a 10"
  else
    puts "El número es igual a 10"
  end
end

Prúebalo con un número menor a 10, otro mayor a 10 y con 10. Te debería mostrar "El número es menor a 10", "El número es mayor a 10" y "El número es igual a 10" respectivamente.

De lo contrario, si (else if)

En general, es preferible no tener que anidar condicionales porque son difíciles de leer y entender. Otro atajo que nos ofrece Ruby para los condicionales es el elsif, que significa "de lo contrario, si" en Inglés. La sintaxis es la siguiente:

if <condicion_1>
  # código que se ejecuta si se cumple la condición_1
elsif <condicion_2>
  # código si <condicion_1> NO se cumple, pero <condicion_2> sí
elsif <condicion_3>
  # código si <condicion_1> y <condicion_2> NO se cumplen, pero <condicion_3> sí
else
  # código si ninguna de las condiciones se cumple
end

Puedes definir tantos elsif como desees. El else es opcional.

Modifiquemos nuestro ejemplo anterior y en vez de utilizar condiciones anidadas, utilicemos else if:

print "Ingresa un número: "
num = gets.chomp.to_i

if num < 10
  puts "El número es menor a 10"
elsif num > 10
  puts "El número es mayor a 10"
else
  puts "El número es igual a 10"
end

Lo más importante de entender en este código es que el programa sólo va a entrar a una de estas ramas. Por ningún motivo va a entrar a dos de ellas. Si la condición del primer if se cumple, el programa ejecuta el código que esté en ese bloque y después salta hasta después del else para continuar con el resto del programa o terminar.

Si la condición del primer if no se cumple, pero la del elsif sí se cumple, el programa ejecuta el código de ese bloque y salta hasta después del else para continuar con el resto del programa o terminar.

Condiciones compuestas

Imagina que queremos escribir un programa que imprima "El número está entre 10 y 20" si el valor de una variable está efectivamente entre 10 y 20. ¿Cómo te imaginas que lo podríamos solucionar?

Una opción es usar condiciones anidadas, de esta forma:

num = 15

if num >= 10
  if num <= 20
    puts "El número está entre 10 y 20"
  end
end

Sin embargo, cómo decíamos antes, leer condiciones anidadas es difícil y, en lo posible, es mejor evitarlas. En cambio, podemos utilizar los operadores lógicos y (&&) y ó (||) para crear condiciones compuestas. El ejemplo anterior lo podemos mejorar con y:

num = 15

if num >= 10 && num <= 20
  puts "El número está entre 10 y 20"
end

La y se representa con &&. Lo que estamos diciendo con este código es: si el número es mayor o igual a 10 y menor o igual 20 entonces imprima "El número está entre 10 y 20". Fíjate que a cada lado del && hay una expresión que evalúa a verdadero o falso: num >= 10 y num <= 20.

También existe el o, que se representa con ||. Imagina ahora que necesitamos escribir un programa que imprima "Excelente elección" cuando el valor de una variable sea "rojo" o "negro":

color = gets.chomp

if color == "negro" || color == "blanco"
  puts "Excelente elección"
end

Pensando como un programador

Vamos a jugar un juego llamado Verdadero o Falso. Yo digo una afirmación y tu debes reponder "verdadera" si la afirmación es verdadera o "falsa" si es falsa. Trata de no mirar las respuestas debajo. Después comparas:

La Tierra gira alrededor del sol.
Paris es la capital de Estados Unidos.
La Tierra gira alrededor del sol y los leones son animales.
Paris es la capital de Estados Unidos y los leones son animales.
La Tierra gira alrededor de Marte y los perros hablan Español.
Los leones son animales o la Tierra gira alrededor del sol.
Paris es la capital de Estados Unidos o los leones son animales.
El planeta tierra gira alrededor de Marte o los perros hablan Español.

Las respuestas son las siguientes:

Verdadera.
Falsa.
Verdadera.
Falsa.
Falsa.
Verdadera.
Verdadera.
Falsa.

Fíjate que cuando utilizamos y las dos afirmaciones deben ser verdaderas para que el resultado sea verdadero. Cuando utilizamos o cualquiera de las dos afirmaciones puede ser verdadera para que el resultado sea verdadero.

Evaluando expresiones booleanas

Volvamos a jugar el juego, pero en vez de utilizar afirmaciones, utilicemos expresiones booleanas. Debes decidir si cada una de las siguientes expresiones es verdadera o falsa (true o false):

true
false
1 < 1
2 != 3
1 < 1 && 2 != 3

Copia y pega cada expresión en IRB para conocer las respuestas.

Analicemos la última expresión: 1 < 1 && 2 != 3. ¿Cómo podemos saber si es verdadera o falsa?

El primer paso es reemplazar cada lado de la expresión. 1 < 1 es false y 2 != 3 es true. Quedaría:

false && true

Recuerda que para que una expresión con y (&&) sea verdadera, cada lado tiene que ser verdadero. Sin embargo, podemos hacer una tabla con todas las combinaciones entre verdadero y falso para poder usarla como referencia más adelante:

Fíjate que para que el resultado sea true los dos lados del && deben ser true.

Hagamos lo mismo para el o (||):

Con el ó cualquiera de los lados puede ser true para que el resultado sea true.

A estas tablas se les conoce como Tablas de Verdad.

Hagamos algunos ejercicios. Decide si las siguientes expresiones evalúan a true o false. Primero reemplaza cada lado del && o el || y luego utiliza las tablas de verdad:

"hola" == "hola" && 1 < 2
true && 5 != 5
1 == 1 || 2 != 1

Revisa tu respuesta evaluando cada expresión en IRB.

Podemos negar cualquier expresión booleana anteponiendo un signo de exclamación (!). Por ejemplo:

!true es false
!false es true

De hecho, esa es la tabla de verdad de la negación. Intenta los siguientes ejercicios. Primero reemplaza lo que está entre paréntesis y luego aplica la tabla de verdad de la negación:

!(1 === 1)
!(2 <= 3)
!(true && 5 !== 5)
!(1 < 1 && 2 !== 3)

El proceso para solucionar cualquier expresión booleana, sin importar qué tan compleja sea, es el siguiente:

Evalúa los operadores de igualdad (<, >, ===, !== etc).
Evalúa los && y || que esten dentro de paréntesis.
Evalúa las negaciones (!).
Evalúa cualquier && y || que falte.

Hagamoslo juntos. Intentemos evaluar la siguiente expresión booleana:

3 != 4 && !("pedro" === "juan" || 26 > 10)

Evaluar los operadores de igualdad:
```
true && !(false || true)
```
Evaluar los && y || que estén dentro de paréntesis:
```
true && !true
```
Evaluar las negaciones:
```
true && false
```
Evaluar cualquier && y || que falte:
```
false
```

Inténtalo tu. Decide si las siguientes expresiones evalúan a true o false:

!(5 === 5) && 8 !== 8
("gut" === "ikk" && 26 > 30) || ("gut" === "gut" && 26 > 10)
!("testing" == "testing" && !(5 > 8))

Evalúate

¿Cuál es la syntaxis de un if (sin else o elsif)?
¿En qué caso se ejecuta el código que está dentro del if?
¿En qué caso se ejecuta el código que está dentro del else?
¿Cuántos else pueden existir en un condicional?
¿Cuántos elsif pueden existir en un condicional?

¿Qué problema tiene el siguiente código?

if num >= 10 && <= 20
  puts "El número está entre 10 y 20"
end

¿Cuál es el resultado de evaluar !(1 == 1)?
¿Cuál es el resultado de evaluar 3 != 4 && !("pedro" === "juan" || 26 > 10)?

¿Qué imprimiría el siguiente código?

raza = "Persa"
ojos = "verdes"
edad = 3

if ojos == "rojos" || (edad > 2 && edad < 5)
  puts "Me lo llevo!"
else
  puts "Paso!"
end

PreviousVariables y entrada de usuario NextCiclos

Last updated 6 years ago