Der Bauernhof

raise "This is an error"

raise ArgumentError.new("This is an argument error")

begin
 raise "This is an error"
rescue
 puts "An error occurred!"
end

begin
 raise "This is an error"
rescue ex
 puts "An error occurred: #{ex.message}"
end

begin
 raise ArgumentError.new("This is an argument error")
rescue ArgumentError
 puts "An argument error occurred!"
end

# or

begin
 raise ArgumentError.new("This is an argument error")
rescue ex : ArgumentError
 puts "An argument error occurred: #{ex.message}"
end

begin
 raise ArgumentError.new("This is an argument error")
rescue ArgumentError
 puts "An argument error occurred!"
rescue
 puts "An error occurred!"
end

begin
 puts "No error occurred"
rescue
 puts "An error occurred!"
else
 puts "No error occurred"
end

begin
 raise "This is an error"
rescue
 puts "An error occurred!"
ensure
 puts "This is always executed"
end

class MyException < Exception
 def initialize
   @message = "This is my exception"
 end
end

raise MyException.new

Anleitung

Der Tag, auf den du so lange gewartet hast, ist endlich gekommen: Du bist jetzt der stolze Besitzer einer wunderschönen Farm in den Alpen.

Es gefällt dir immer noch nicht, morgens zu früh aufzustehen, um deine Kühe zu füttern. Weil du ein ausgezeichneter Ingenieur bist, baust du einen Futterspender, den FEED-M-ALL.

Das Letzte, was noch fehlt, um dein Projekt abzuschließen, ist ein Stück Code, das die Futtermenge berechnet, die jede Kuh bekommen soll. Es ist wichtig, dass jede Kuh die gleiche Menge bekommt, du musst Konflikte vermeiden. Kühe sind sehr sensibel.

Zum Glück musst du nicht alle Formeln zur Berechnung der Futtermenge selbst herleiten. Du verwendest eine geheimnisvolle externe Bibliothek, die du im Internet gefunden hast. Sie soll für die glücklichsten Kühe sorgen. Die Bibliothek stellt eine Klasse bereit, die die folgende Schnittstelle erfüllt. Darauf wirst du dich in dem Code verlassen, den du selbst schreibst.

class FodderCalculator
  def fodder_amount! : Number 
  end

  def fattening_factor! : Number
  end
end

Während du an deinem Code arbeitest, wirst du die Fehlerbehandlung verbessern, damit sie robuster und später leichter zu debuggen ist, wenn du sie in deinem täglichen Farmleben einsetzt.

1. Verteile das Futter gleichmäßig

Zuerst konzentrierst du dich darauf, den Code zu schreiben, der benötigt wird, um die Futtermenge pro Kuh zu berechnen.

Implementiere eine Methode TheFarm.divide_food, die ein Objekt vom Typ FodderCalculator und eine Anzahl Kühe als Ganzzahl als Argumente entgegennimmt. Für diese Aufgabe gehst du davon aus, dass die übergebene Anzahl Kühe immer größer als null ist. Die Methode sollte die Futtermenge pro Kuh zurückgeben.

Um die Berechnung durchzuführen, musst du zuerst die Gesamtfuttermenge für alle Kühe abrufen. Das machst du, indem du die Methode fodder_amount! aufrufst und die Anzahl der Kühe übergibst. Außerdem brauchst du einen Faktor, mit dem diese Menge multipliziert werden muss. Diesen Faktor erhältst du, indem du die Methode fattening_factor! aufrufst. Mit diesen beiden Werten und der Anzahl der Kühe kannst du nun die Futtermenge pro Kuh berechnen (als float64).

Wenn eine der Methoden, die du aufrufst, einen Fehler zurückgibt, sollte die Ausführung stoppen und 0 zurückgeben.

fodder_calculator = FodderCalculator.new(50, 1.5)
TheFarm.divide_food(fodder_calculator, 5)
# => 15.0

fodder_calculator = FodderCalculator.new(50, nil)
TheFarm.divide_food(fodder_calculator, 5)
# => 0

2. Überprüfe die Anzahl der Kühe

Während du an der ersten Aufgabe oben gearbeitet hast, hast du gemerkt, dass die externe Bibliothek, die du verwendest, nicht so hochwertig ist, wie du dachtest. Zum Beispiel kann sie ungültige Eingaben nicht richtig verarbeiten. Du möchtest diese Einschränkung umgehen, indem du in deinem eigenen Code eine Prüfung des Eingabewerts hinzufügst.

Schreibe eine Funktion TheFarm.validate_input_and_divide_food, die dieselbe Signatur hat wie TheFarm.divide_food oben.

• Wenn die übergebene Anzahl der Kühe größer als 0 ist, sollte die Funktion TheFarm.divide_food aufrufen und die Ergebnisse dieses Aufrufs zurückgeben.
• Wenn die Anzahl der Kühe 0 oder kleiner ist, sollte die Funktion einen Fehler mit der Meldung "Number of cows must be greater than 0" auslösen.

TheFarm.validate_input_and_divide_food(fodderCalculator, 5)
# => 15

TheFarm.validate_input_and_divide_food(fodderCalculator, -2)
# Error: Number of cows must be greater than 0

3. Verbessere die Fehlerbehandlung

Die Anzahl der Kühe zu prüfen, bevor du sie weitergibst, war ein guter Schachzug, aber mit der unspezifischen Fehlermeldung bist du nicht ganz zufrieden. Du beschließt, es besser zu machen, indem du eine eigene Fehlerklasse namens InvalidCowsError erstellst.

Der eigene Fehler sollte die Anzahl der Kühe (Int32) und eine eigene Meldung (String) enthalten, und die Methode Expection sollte die Daten im folgenden Format serialisieren:

{number of cows} cows are invalid: {custom message}

Ausgestattet mit deinem eigenen Fehler, implementiere eine Funktion TheFarm.validate_number_of_cows, die die Anzahl der Kühe als Ganzzahl entgegennimmt und einen Fehler (oder nil) zurückgibt.

• Wenn die Anzahl der Kühe kleiner als 0 ist, gibt die Funktion einen InvalidCowsError zurück, bei dem die eigene Meldung auf "there are no negative cows" gesetzt ist.
• Wenn die Anzahl der Kühe 0 ist, gibt die Funktion einen InvalidCowsError zurück, bei dem die eigene Meldung auf "no cows don't need food" gesetzt ist.
• Andernfalls gibt die Funktion nil zurück, um anzuzeigen, dass die Validierung erfolgreich war.

TheFarm.validate_number_of_cows(5)
# => nil

TheFarm.validate_number_of_cows(-5)
# => InvalidCowsError: -5 cows are invalid: there are no negative cows

Nach der harten Arbeit, diese Validierungsfunktion aufzusetzen, fällt dir auf, dass es bereits Abend ist, und du verlässt deinen Schreibtisch, um den Sonnenuntergang über den Bergen zu genießen. Die Aufgabe, die neue Validierungsfunktion tatsächlich in deinen Code einzubauen, verschiebst du auf einen anderen Tag.