Introduzione
Le eccezioni in Ruby, come in molti linguaggi, offrono un modo per gestire eventi imprevisti. Una corretta gestione delle eccezioni è importante quando si cerca di evitare che il programma vada in crash.
Quando viene sollevata un'eccezione, o perché la sollevi esplicitamente o perché la solleva l'interprete Ruby, il programma interrompe il normale funzionamento e alla fine termina con un messaggio di errore:
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)
Se vogliamo impedire questo arresto, dobbiamo reagire all'eccezione. Questa operazione si chiama «recupero» di un'eccezione:
begin
# ...any code that raises an exception
rescue
puts 'Got an exception'
end
Questo programma non andrà in crash e produrrà come output «Got an exception». Anziché uscire, Ruby esegue il codice nel blocco rescue, che stampa un messaggio.
Come ogni cosa in Ruby, anche le eccezioni sono oggetti e di solito contengono dati sull'eccezione. Ecco come possiamo ottenere l'oggetto eccezione:
begin
# ...any code that raises an exception
rescue => e
puts "Exception class: #{ e.class.name }"
puts "Exception Message:#{e.message}"
end
In Ruby è anche possibile sollevare le proprie eccezioni. Per esempio:
begin
raise ArgumentError.new("Invalid argument")
rescue ArgumentError => e
puts e.message
end
L'eccezione precedente è una delle eccezioni integrate di Ruby, ma è anche possibile definire eccezioni personalizzate e sollevarle:
class CustomError < StandardError
end
raise CustomError.new("Something went wrong")
Istruzioni
In questo esercizio costruirai la gestione degli errori per una semplice calcolatrice.
L'obiettivo è avere una calcolatrice funzionante che restituisce una stringa con il seguente formato: 16 + 51 = 67, quando riceve gli argomenti 16, 51 e +.
SimpleCalculator.calculate(16, 51, "+")
# => "16 + 51 = 67"
SimpleCalculator.calculate(32, 6, "*")
# => "32 * 6 = 192"
SimpleCalculator.calculate(512, 4, "/")
# => "512 / 4 = 128"
1. Gestire il codice che può sollevare errori all'interno del metodo calculate
Il metodo principale da implementare in questa attività sarà il metodo di classe SimpleCalculator.calculate().
Accetta tre argomenti.
I primi due argomenti sono numeri sui quali verrà eseguita un'operazione.
Il terzo argomento è di tipo stringa e per questo esercizio è necessario implementare le seguenti operazioni:
- l'addizione usando la stringa
+
- la moltiplicazione usando la stringa
*
- la divisione usando la stringa
/
2. Gestire le operazioni non valide
Aggiorna il metodo SimpleCalculator.calculate() in modo che sollevi un'eccezione UnsupportedOperation per i simboli di operazione sconosciuti.
SimpleCalculator.calculate(1, 2, '-')
# => Raises an UnsupportedOperation
In questo esercizio, ci si aspetta che tu definisca l'eccezione UnsupportedOperation per uno scope specifico.
3. Gestire argomenti non validi
Aggiorna il metodo SimpleCalculator.calculate() in modo che sollevi un'eccezione ArgumentError per i tipi di argomento non validi.
SimpleCalculator.calculate(1, '2', '*')
# => Raises an ArgumentError
4. Gestire le eccezioni DivideByZero
Aggiorna il metodo SimpleCalculator.calculate() per gestire le eccezioni ZeroDivisionError.
Il codice di gestione dovrebbe restituire la stringa con il contenuto Division by zero is not allowed..
Qualsiasi altra eccezione non deve essere gestita dal metodo SimpleCalculator.calculate().
SimpleCalculator.calculate(512, 0, "/")
# => returns "Division by zero is not allowed."
Esercizio di apprendimento
