Nivel inicial6 min de lectura · Publicado el

Condicionales en Ruby: if, unless, case y ternario

Condicionales en Ruby: una taquilla con tres tarifas, if edad < 18, elsif edad < 21 y else; con edad = 16 se aplica la primera. Gana la primera condiciónrubentejera.com edad = 16if edad < 18elsif edad < 21else→ "Eres menor de edad"
La taquilla lee las tarifas de arriba abajo, como if, elsif y else, y aplica la primera que se cumple. Con edad = 16 ya vale la primera, «Eres menor de edad», y las demás ni se miran.

Un condicional es como la taquilla de un cine con tarifas por edad: según se cumpla o no una condición, el programa hace una cosa u otra. Ruby tiene varias formas de escribirlo, y cada una encaja mejor en un caso.

if en Ruby: if, elsif y else

edad = 16

if edad < 18
  puts "Eres menor de edad"
elsif edad < 21
  puts "Eres mayor de edad, pero no puedes pasar"
else
  puts "Eres mayor de edad y puedes pasar"
end
# Eres menor de edad

Ruby comprueba las condiciones de arriba abajo y ejecuta solo el primer bloque que se cumpla. Fíjate en que se escribe elsif, sin la e de else (comprobado con Ruby 3.4.12). Detrás de la condición puedes escribir then, pero es opcional; solo se suele poner cuando todo va en una línea: if edad < 18 then puts "menor" end (comprobado con Ruby 3.4.12).

Qué es verdadero y qué es falso

Cualquier valor que no sea nil ni false es verdadero. Esto sorprende si vienes de otros lenguajes:

Valor ¿Verdadero o falso?
nil Falso
false Falso
0 Verdadero
"" (texto vacío) Verdadero
[] (lista vacía) Verdadero
"false" (texto) Verdadero
En Ruby, el 0 no es falso.

Gracias a esto puedes escribir bucles como este. gets devuelve la siguiente línea de la entrada y, al llegar al final, devuelve nil, así que el bucle se para solo:

while (linea = gets)
  puts "Leída: #{linea}"
end

if y unless en una línea

Si la condición es corta, puedes ponerla al final de la línea:

puts "Puedes votar" if edad >= 18
puts "Aún no puedes votar" unless edad >= 18

unless es lo contrario de if: ejecuta el código cuando la condición no se cumple. Úsalo con condiciones sencillas; con un unless … else el código se lee peor que con un if.

El operador ternario

Es un if … else en una sola línea: condición ? valor_si_se_cumple : valor_si_no.

nombre = "ana"
puts nombre == "ana" ? "Correcto" : "Incorrecto"   # Correcto

duracion = 100
precio = duracion > 120 ? 1 : 0.75
puts precio   # 0.75

case y when: el switch de Ruby

Cuando tienes muchas opciones, case se lee mejor que una cadena de elsif. Puedes escribir cada condición completa:

anio = 1985

decada = case
         when anio == 1985 then "80's"
         when anio == 1986 then "80's"
         when anio == 1992 then "90's"
         else "Sin definir"
         end

puts decada   # 80's

O, mejor, poner el valor después de case y comparar con rangos:

anio = 1992

decada = case anio
         when 1980..1989 then "80's"
         when 1990..1999 then "90's"
         else "Sin definir"
         end

puts decada   # 90's

Como case devuelve un valor, puedes guardarlo directamente en una variable.

Un paso más: case con in

Desde Ruby 3, case … in compara la forma de los datos (pattern matching) y saca valores a variables:

usuario = { nombre: "Ana", rol: :admin }

case usuario
in { rol: :admin, nombre: }
  puts "#{nombre} es administradora"
in { rol: :invitado }
  puts "Invitado"
end
# Ana es administradora

Por qué when acepta rangos y clases

case no compara con ==, sino con ===, que cada tipo de objeto interpreta a su manera. Un rango responde si el valor está dentro; una clase, si el valor es de esa clase:

puts (1980..1989) === 1985   # true
puts Integer === 5           # true

valor = "42"
tipo = case valor
       when Integer then "número"
       when String  then "texto"
       end
puts tipo   # texto

Por eso "42" sale como texto: va entre comillas, así que es un String, aunque parezca un número.

Errores frecuentes

1. Escribir = en lugar de ==. Un solo = asigna, no compara. La condición vale lo que asignas y, como 30 es verdadero, siempre entra:

edad = 16
if edad = 30
  puts "Siempre entra; edad ahora vale #{edad}"
end
warning: found '= literal' in conditional, should be ==
Siempre entra; edad ahora vale 30

Ruby avisa cuando asignas un valor fijo, como 30. Si asignas otra variable (if edad = otra_edad), no avisa.

2. Escribir else if en lugar de elsif. else if abre un if nuevo dentro del else, que necesita su propio end. Con un solo end, Ruby no puede leer el fichero:

if edad < 18
  puts "menor"
else if edad < 21
  puts "joven"
end
Unmatched keyword, missing `end' ?
else_if.rb:5: syntax errors found (SyntaxError)

3. Comprobar una lista vacía con if lista. Una lista vacía es verdadera, como se ve en la tabla de arriba. Para saber si tiene algo, pregúntaselo:

carrito = []
puts(carrito ? "Hay algo" : "Vacío")              # Hay algo (¡mal!)
puts(carrito.empty? ? "Vacío" : "Hay algo")       # Vacío

4. Comparar un texto con un símbolo. "admin" es un texto y :admin es un símbolo. Se parecen, pero no son iguales:

rol = "admin"
puts rol == :admin   # false

Pasa mucho con datos que llegan de un formulario o de un fichero, que siempre son texto. Convierte uno de los dos antes de comparar: rol.to_sym == :admin.

5. Olvidar el else en un case que guarda un valor. Si ningún when coincide y no hay else, el case devuelve nil, y el fallo aparece más tarde, lejos de su origen:

decada = case 2030
         when 1980..1989 then "80's"
         end
p decada   # nil

6. Usar and y or como si fueran && y ||. Hacen lo mismo, pero con menos prioridad que el =. En la segunda línea, Ruby asigna false a y y solo después evalúa el or:

x = false || true
y = false or true
p x   # true
p y   # false

Para condiciones, usa siempre && y ||.

Compruébalo con un test

Los fallos de los condicionales casi siempre están en los bordes: ¿18 años ya es «joven» o todavía «menor»? Un test que pruebe justo los valores límite lo deja escrito. Este, con Minitest (incluido en Ruby), mete la taquilla del principio en un método:

require "minitest/autorun"

def tarifa(edad)
  if edad < 18
    "menor"
  elsif edad < 21
    "joven"
  else
    "adulto"
  end
end

class TarifaTest < Minitest::Test
  def test_los_limites_de_cada_tramo
    assert_equal "menor",  tarifa(17)
    assert_equal "joven",  tarifa(18)
    assert_equal "joven",  tarifa(20)
    assert_equal "adulto", tarifa(21)
  end
end
ruby tarifa_test.rb
1 runs, 4 assertions, 0 failures, 0 errors, 0 skips

Si alguien cambia edad < 18 por edad <= 18, el código sigue pareciendo correcto, pero el test lo detecta:

Expected: "joven"
  Actual: "menor"

Da igual quién haga el cambio, una persona o un asistente de IA que «ordena» el código: el test se pone en rojo antes de que el error llegue a la taquilla. Para empezar con tests en Ruby, lee la introducción al testing en Ruby.

Cuándo no usar un condicional

Un if o un case es la herramienta correcta para una decisión con pocas ramas. Hay dos señales de que conviene otra cosa:

  • El case solo traduce un valor a otro. Una tabla de equivalencias se lee mejor como un hash, y añadir una opción es añadir una línea, no una rama:
DECADAS = { 1980 => "80's", 1990 => "90's" }.freeze

def decada(anio) = DECADAS.fetch(anio / 10 * 10, "Sin definir")

puts decada(1985)   # 80's
puts decada(2030)   # Sin definir

anio / 10 * 10 redondea hacia abajo a la década (1985 → 1980), porque la división entre enteros descarta los decimales. fetch devuelve el segundo argumento si la clave no existe.

  • El mismo case sobre el tipo de algo se repite en varios sitios. Si en tres métodos preguntas «¿es un coche, una moto o un camión?», cada tipo nuevo te obliga a tocar los tres. Suele ser mejor que cada clase tenga su propio método y que Ruby elija cuál ejecutar. Es la idea del principio abierto/cerrado, explicado en principios SOLID.

Cuantas más ramas tiene un método, más caminos hay que probar. Esa cuenta tiene nombre: complejidad ciclomática.

Ejercicio de cinco minutos

  1. Copia el test de tarifa y añade un tramo nuevo: desde 65 años, "senior". Escribe primero el test con 64 y 65, y comprueba que falla.
  2. Haz que pase con un elsif más. ¿Dónde tienes que ponerlo para que funcione?
  3. Reescribe tarifa con case edad y rangos (when 0...18). Si el test sigue en verde, el cambio es seguro.

Para seguir, mira los operadores en Ruby, que son los que construyen las condiciones, y los bucles e iteradores.

Fuentes

Comprobado en noviembre de 2026 en la documentación oficial de Ruby 3.4: Control Expressions (if, elsif, unless, case con ===, and y or), Pattern Matching, Operator Precedence (and y or por debajo de =) y Hash#fetch.

Todos los ejemplos, y la tabla de valores verdaderos y falsos, se han ejecutado en Docker con la imagen ruby:3.4 (Ruby 3.4.12): los del artículo original el 7 de noviembre de 2026; los errores frecuentes, el test (Minitest 5.25.4) y el hash de décadas, el 11 de noviembre de 2026. El bucle con gets se ha probado leyendo un fichero de dos líneas. Las salidas de error están recortadas a las líneas que importan.