Ruby trata erros com begin/rescue/ensure (equivalente do try/catch/finally do Ruby). Você raise exceções e as rescue, com ensure para limpeza. Ruby também permite rescue no nível do método (sem begin explícito) para um código mais limpo.
A estrutura básica
begin
result = risky_operation
rescue ArgumentError => e # rescue a SPECIFIC exception type
puts "Bad argument: #{e.message}"
rescue StandardError => e # broader catch (StandardError, not Exception)
puts "Error: #{e.message}"
retry if attempts < 3 # retry can re-run the begin block
else
puts "succeeded" # runs if NO exception
ensure
cleanup # ALWAYS runs (success or failure)
end
begin/rescue/ensure é o try/catch/finally do Ruby. Resgate tipos específicos (rescue ArgumentError), use ensure para limpeza garantida, e else para o caso sem erro. retry pode tentar novamente o bloco.
Uma ressalva importante do Ruby: resgate StandardError, não Exception
rescue => e # ✅ bare rescue catches StandardError (the right default)
rescue StandardError # ✅ explicit, same thing
rescue Exception # ❌ AVOID — catches EVERYTHING including system signals
# (Interrupt/Ctrl-C, SystemExit) — can break the program
Importante: um rescue simples captura StandardError (o padrão correto para erros de aplicação). Resgatar Exception (a raiz) captura tudo, incluindo sinais de nível do sistema como Interrupt (Ctrl-C) e SystemExit — o que geralmente você não quer capturar, pois pode impedir que o programa seja interrompido ou encerrado adequadamente. Um erro comum em Ruby.
Levantando e exceções customizadas
raise ArgumentError, "Amount must be positive" # raise a built-in
raise "Something failed" # raises RuntimeError
# custom exception class
class InsufficientFundsError < StandardError # inherit from StandardError
def initialize(msg = "Not enough funds")
super
end
end
raise InsufficientFundsError
Rescue no nível do método (mais limpo)
def process
do_work
rescue => e # rescue WITHOUT begin — applies to the whole method body
handle(e)
ensure
cleanup
end
Por que isso importa
O tratamento adequado de exceções é essencial para aplicações Ruby robustas, e entender a abordagem do Ruby — incluindo seus idiomas e ressalvas específicas — é importante.
A estrutura begin/rescue/ensure (o try/catch/finally do Ruby), resgatar tipos de exceção específicos, usar ensure para limpeza garantida, e o rescue no nível do método (sem begin explícito) são conhecimentos fundamentais do dia a dia.
Um ponto particularmente importante e distintivamente Ruby é a distinção StandardError vs Exception: um rescue simples (e o padrão correto) captura StandardError, mas resgatar Exception (a raiz da hierarquia) captura tudo — incluindo sinais do sistema como Interrupt (Ctrl-C) e SystemExit — o que você quase nunca quer, pois pode impedir que o programa seja interrompido ou encerrado adequadamente, e é um erro comum e prejudicial.
Entender que você deve resgatar StandardError (não Exception) para erros de aplicação é um conhecimento importante e específico do Ruby que previne bugs reais.
Conhecer a estrutura, classes de exceção customizadas (herdando de StandardError), retry, o idioma do rescue no nível do método, e especialmente a ressalva StandardError-não-Exception é importante para escrever Ruby robusto e correto que trata erros graciosamente sem quebrar a capacidade do programa de ser interrompido.
Como erros não tratados e o erro de resgatar Exception causam problemas reais, dominar o tratamento de exceções do Ruby — sua estrutura, idiomas, e a distinção crítica StandardError vs Exception — é um conhecimento importante, frequentemente relevante para desenvolvimento Ruby confiável e um tópico comum em entrevistas.