Ruby Academy · Aula

Cláusulas de guarda

Retornos antecipados limpos.

Cláusulas de guarda é uma aula grátis de Ruby Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Ruby Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Ruby Academy inclui 4 aulas no total.

Retornos antecipados claros

Uma cláusula de guarda é uma verificação no início de um método que retorna antecipadamente para casos inválidos ou extremos. Ela mantém a lógica principal plana e fácil de ler.

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

O problema: aninhamento profundo

Sem guardas, as validações se acumulam como blocos if aninhados. O trabalho real acaba enterrado bem à direita da tela.

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

A solução: cláusulas de guarda

Inverta cada condição e retorne antecipadamente. O caminho de sucesso agora fica no nível básico de indentação, sem recuo e evidente.

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

return sem valor

Um return sozinho sai do método e produz nil. Use-o quando quem chama não precisar de um resultado para o caso rejeitado.

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

Retornando um valor

Uma guarda também pode retornar um valor significativo, como um padrão sensato, para que quem chama sempre receba algo utilizável.

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

Guarda com unless

return unless condition pode ser lido como “saia se este requisito não for atendido”. Esse é um dos idiomas mais comuns do Ruby.

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

Várias guardas

Empilhe várias guardas para validar as entradas uma por uma. Cada linha expressa uma única regra, tornando o método autoexplicativo.

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)

Guardas com next em laços

Dentro de um bloco ou laço, você não pode usar return para retornar apenas de uma iteração. Use next como guarda para pular para o próximo item.

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

Guardas melhoram a legibilidade

Compare mentalmente os dois estilos abaixo: as guardas removem o else e reduzem a indentação. Os leitores veem primeiro os casos inválidos sendo tratados e, depois, a 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)

Gerando uma exceção em uma guarda

Quando uma entrada inválida for um erro de programação, e não um caso esperado, gere uma exceção na guarda para falhar rapidamente e de forma explícita.

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"

Juntando tudo

As cláusulas de guarda são um pequeno hábito com grande benefício:

Trate os casos extremos logo no início e retorne.
Mantenha a lógica principal sem indentação.
Use return/next/raise conforme a situação exigir.

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")

Verificação rápida

Teste sua compreensão das cláusulas de guarda.

Recapitulação

Você aprendeu sobre cláusulas de guarda:

Retorne antecipadamente para casos inválidos ou extremos.
return unless sai quando um requisito não é atendido.
Use next para pular uma iteração do laço e raise para erros verdadeiros.
O resultado são métodos planos e autoexplicativos.

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

Perguntas Frequentes

A aula “Cláusulas de guarda” é grátis?

Sim — o texto completo de “Cláusulas de guarda” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Ruby Academy, atualize para CoddyKit PRO. O curso de Ruby Academy inclui 4 aulas no total.

O que vou aprender em “Cláusulas de guarda”?

Retornos antecipados limpos. Você pratica Ruby Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Ruby Academy?

Nenhuma experiência prévia é necessária. Ruby Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Cláusulas de guarda”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Ruby Academy?

Sim. Cada aula de Ruby Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Ruby Academy