Ruby Academy · Lección

Cláusulas de guarda

Retornos anticipados más claros

Cláusulas de guarda es una lección gratuita de Ruby Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Ruby Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Ruby Academy incluye 4 lecciones en total.

Retornos anticipados claros

Una cláusula de guarda es una comprobación al principio de un método que retorna anticipadamente para gestionar casos no válidos o límite. Mantiene la lógica principal plana y fácil de leer.

def greet(name)
  return "Hello, stranger" if name.nil?
  "Hello, #{name}"
end
puts greet(nil)
puts greet("Ada")

El problema: anidación profunda

Sin cláusulas de guarda, las validaciones se acumulan como bloques if anidados. El trabajo principal acaba enterrado en lo más profundo, junto al borde derecho de la pantalla.

def charge(user)
  if user
    if user[:active]
      puts "Charging #{user[:name]}"
    end
  end
end
charge({ name: "Sam", active: true })

La solución: cláusulas de guarda

Invierta cada condición y retorne anticipadamente. Ahora el flujo principal se encuentra en el nivel base de sangría, sin sangría adicional y resulta evidente.

def charge(user)
  return unless user
  return unless user[:active]
  puts "Charging #{user[:name]}"
end
charge({ name: "Sam", active: true })

return sin valor

Un return sin expresión sale del método y produce nil. Utilícelo cuando el llamador no necesite un resultado para el caso rechazado.

def log(message)
  return if message.nil? || message.empty?
  puts "LOG: #{message}"
end
log("")
log("started")

Devolver un valor

Una cláusula de guarda también puede devolver un valor significativo, como un valor predeterminado razonable, para que los llamadores siempre reciban algo utilizable.

def discount(price)
  return 0 if price <= 0
  price * 0.1
end
puts discount(-5)
puts discount(200)

Cláusula de guarda con unless

return unless condition se interpreta como «salga si no se cumple este requisito». Es uno de los modismos más habituales de Ruby.

def withdraw(balance, amount)
  return "Insufficient funds" unless balance >= amount
  "New balance: #{balance - amount}"
end
puts withdraw(100, 150)
puts withdraw(100, 40)

Varias cláusulas de guarda

Encadene varias cláusulas de guarda para validar las entradas una por una. Cada línea expresa una única regla, lo que hace que el método se documente por sí mismo.

def register(name, age)
  return "Name required" if name.to_s.empty?
  return "Must be 18+" if age < 18
  "Registered #{name}"
end
puts register("", 30)
puts register("Lee", 16)
puts register("Lee", 21)

Cláusulas de guarda con next en bucles

Dentro de un bloque o bucle, no puede utilizar return para salir solo de una iteración. Utilice next como cláusula de guarda para pasar al elemento siguiente.

[1, -2, 3, -4].each do |n|
  next if n.negative?
  puts n
end

Las cláusulas de guarda mejoran la legibilidad

Compare mentalmente los dos estilos siguientes: las cláusulas de guarda eliminan el else y reducen la sangría. El lector ve primero cómo se gestionan los casos no válidos y después la lógica principal.

def area(width, height)
  return 0 unless width.positive? && height.positive?
  width * height
end
puts area(0, 5)
puts area(4, 5)

Lanzar una excepción en una cláusula de guarda

Cuando una entrada incorrecta es un error del programador y no un caso esperado, lance una excepción en la cláusula de guarda para fallar de forma rápida y visible.

def sqrt(n)
  raise ArgumentError, "n must be >= 0" if n.negative?
  Math.sqrt(n)
end
puts sqrt(16)
puts sqrt(-1) rescue puts "caught negative input"

Cómo encaja todo

Las cláusulas de guarda son un pequeño hábito con grandes beneficios:

Gestione los casos límite al principio y retorne.
Mantenga la lógica principal sin sangría adicional.
Utilice return/next/raise según lo requiera la situación.

def initials(name)
  return "" if name.nil? || name.strip.empty?
  name.split.map { |part| part[0].upcase }.join
end
puts initials("  ").inspect
puts initials("grace hopper")

Comprobación rápida

Compruebe cuánto ha entendido sobre las cláusulas de guarda.

Repaso

Ha aprendido las cláusulas de guarda:

Retorne anticipadamente para los casos no válidos o límite.
return unless abandona el método cuando no se cumple un requisito.
Utilice next para omitir una iteración del bucle y raise para errores reales.
El resultado son métodos planos que se documentan por sí mismos.

def safe_divide(a, b)
  return nil if b.zero?
  a / b
end
puts safe_divide(10, 0).inspect
puts safe_divide(10, 2)

Preguntas frecuentes

¿La lección «Cláusulas de guarda» es gratis?

Sí — el texto completo de «Cláusulas de guarda» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Ruby Academy, actualiza a CoddyKit PRO. El curso de Ruby Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Cláusulas de guarda»?

Retornos anticipados más claros Practicas Ruby Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Ruby Academy?

No se requiere experiencia previa. Ruby Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Cláusulas de guarda»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Ruby Academy?

Sí. Cada lección de Ruby Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Ruby Academy