Excepciones

Las excepciones nos permiten interrumpir el flujo normal del programa para indicar que algo inesperado ha sucedido.

Seguramente ya has visto excepciones como SyntaxError que se dispara cuando tienes un error de sintaxis en el código o NoMethodError cuando intentas invocar un método que no existe.

Cuando se dispara una excepción el programa interrumpe el código y termina a menos de que alguien intercepte la excepción y la maneje.

Interceptando excepciones

begin
1 / 0 # esto lanza una excepción ZeroDivisionError
rescue
# este código se ejecuta cuando ocurre una excepción
end

Si queremos ver el mensaje y el stacktrace podemos asignar la excepción a una variable:

begin
1 / 0
rescue => e
puts e.message # imprime el mensaje
puts e.backtrace.join(`\n`) # imprime el stacktrace
end

Si queremos interceptar solo unas excepciones específicas debemos escribir el nombre de la clase:

begin
1 / 0
rescue ZeroDivisionError => e
# código que se ejecuta cuando ocurre un ZeroDivisionError
end

Lanzando excepciones

Para lanzar una excepción utiliza la palabra clave raise:

raise ArgumentError.new("El argumento es inválido")

Cuando se lanza una excepción debemos decidir qué excepción vamos a lanzar. ArgumentError se utiliza cuando existe un error en un argumento de un método. Otra más común es RuntimeError:

raise RuntimeError.new("No se esperaba que ...")

Otras formas equivalentes en las que puedes lanzar una excepción son:

raise RuntimeError, "No se esperaba que ..."
# lo siguiente genera un RuntimeError
raise "No se esperaba que ..."

Existen muchas más excepciones incluidas con Ruby y están organizadas en una jerarquía de clases. Veamos algunas de ellas:

Exception
NoMemoryError
ScriptError
LoadError
NotImplementedError
SyntaxError
SignalException
Interrupt
StandardError
ArgumentError
IOError
EOFError
IndexError
LocalJumpError
NameError
NoMethodError
RangeError
FloatDomainError
RegexpError
RuntimeError
SecurityError
SystemCallError
SystemStackError
ThreadError
TypeError
ZeroDivisionError
SystemExit

La jerarquía es importante porque cuando capturas, por ejemplo, StandardError, estás capturando cualquier excepción debajo en la jerarquía como ArgumentError, IOError, etc.

En general, uno debe ser lo más específico al capturar excepciones. Evita capturar Exception, es una mala práctica.

Cuando omites la excepción en el rescue realmente estás capturando StandardError (y por lo tanto, cualquier excepción que esté debajo en la jerarquía).

Creando nuestras propias excepciones

También es posible crear nuestras propias excepciones, simplemente crea una clase que extienda de StandardError:

class PermissionDeniedError < StandardError
end
raise PermissionDeniedError.new()

Como una excepción no es más que una clase normal de Ruby, puedes agregarle un constructor, atributos y métodos:

class PermissionDeniedError < StandardError
attr_reader :action
def initialize(message, action)
# Call the parent's constructor to set the message
super(message)
# Store the action in an instance variable
@action = action
end
end
# Cuando alguien trate de borrar algo sin permiso podrías
# hacer algo así:
raise PermissionDeniedError.new("Permission Denied", :delete)