Introducción
Las excepciones en Ruby, como en muchos otros lenguajes, ofrecen una manera de manejar eventos inesperados. Manejar bien las excepciones es importante cuando intentas evitar que tu programa se bloquee.
Cuando se lanza una excepción, ya sea porque la lanzas explícitamente o porque la lanza el intérprete de Ruby, el programa desvía su funcionamiento normal y finalmente termina 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, necesitamos reaccionar ante la excepción. A esto se le 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 terminar, Ruby ejecuta el código del bloque rescue, que imprime un mensaje.
Como todo en Ruby, las excepciones también son objetos y por lo general contienen datos sobre la excepción. Así es como 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 sencilla.
El objetivo es tener una calculadora funcional que devuelva un string con el siguiente patrón: 16 + 51 = 67, cuando recibe 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 generar errores dentro del método calculate
El método principal que implementarás en esta tarea será el método de clase SimpleCalculator.calculate().
Recibe tres argumentos.
Los primeros dos 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 ámbito específico.
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 manejar 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
