Introducción
Las excepciones en Ruby, como en muchos lenguajes, proporcionan una forma de lidiar con eventos inesperados. Manejar bien las excepciones es importante cuando intentas evitar que tu programa se bloquee.
Cuando se lanza una excepción, ya sea lanzándola explícitamente o porque la lance el intérprete de Ruby, el programa interrumpe su funcionamiento normal y acaba saliendo con un mensaje de error:
raise ArgumentError.new("Something went wrong!")
=> Traceback (most recent call last):
.
.
ArgumentError (Something went wrong!)
1/0
=> Traceback (most recent call last):
.
.
ZeroDivisionError (divided by 0)
Si queremos detener este proceso de cierre, tenemos que reaccionar ante la excepción. Esto se llama «rescatar» una excepción:
begin
# ...any code that raises an exception
rescue
puts 'Got an exception'
end
Este programa no se bloqueará y mostrará «Got an exception». En lugar de salir, Ruby ejecuta el código del bloque rescue, que imprime un mensaje.
Al igual que todo en Ruby, las excepciones también son objetos y normalmente contienen datos sobre la excepción. Así podemos obtener el objeto de la excepción:
begin
# ...any code that raises an exception
rescue => e
puts "Exception class: #{ e.class.name }"
puts "Exception Message:#{e.message}"
end
En Ruby también es posible lanzar tus propias excepciones. Por ejemplo:
begin
raise ArgumentError.new("Invalid argument")
rescue ArgumentError => e
puts e.message
end
La excepción anterior es una de las excepciones integradas de Ruby, pero también es posible definir excepciones personalizadas y lanzarlas:
class CustomError < StandardError
end
raise CustomError.new("Something went wrong")
Instrucciones
En este ejercicio vas a implementar el manejo de errores para una calculadora simple.
El objetivo es tener una calculadora funcional que devuelva un string con el siguiente patrón: 16 + 51 = 67, cuando se le pasan los argumentos 16, 51 y +.
SimpleCalculator.calculate(16, 51, "+")
# => "16 + 51 = 67"
SimpleCalculator.calculate(32, 6, "*")
# => "32 * 6 = 192"
SimpleCalculator.calculate(512, 4, "/")
# => "512 / 4 = 128"
1. Maneja el código que puede lanzar errores dentro del método calculate
El método principal que hay que implementar en esta tarea será el método de clase SimpleCalculator.calculate().
Recibe tres argumentos.
Los dos primeros argumentos son números sobre los que se va a realizar una operación.
El tercer argumento es de tipo string y, para este ejercicio, es necesario implementar las siguientes operaciones:
- la suma usando el string
+
- la multiplicación usando el string
*
- la división usando el string
/
2. Maneja las operaciones no válidas
Actualiza el método SimpleCalculator.calculate() para que lance una excepción UnsupportedOperation cuando el símbolo de la operación sea desconocido.
SimpleCalculator.calculate(1, 2, '-')
# => Raises an UnsupportedOperation
En este ejercicio, se espera que definas la excepción UnsupportedOperation para un scope concreto.
3. Maneja los argumentos no válidos
Actualiza el método SimpleCalculator.calculate() para que lance una excepción ArgumentError cuando los tipos de los argumentos no sean válidos.
SimpleCalculator.calculate(1, '2', '*')
# => Raises an ArgumentError
4. Maneja las excepciones DivideByZero
Actualiza SimpleCalculator.calculate() para que maneje las excepciones ZeroDivisionError.
El código de manejo debe devolver el string con el contenido Division by zero is not allowed..
Ninguna otra excepción debe ser manejada por el método SimpleCalculator.calculate().
SimpleCalculator.calculate(512, 0, "/")
# => returns "Division by zero is not allowed."
Ejercicio de aprendizaje
