Einführung
Funktionen mit mehreren Klauseln
Elixir unterstützt Praktiken des Open-Closed Principle, indem Funktionen mehrere Klauseln haben dürfen. Statt ausufernder, fest verdrahteter Steuerlogik kannst du so gezielte Funktionen schreiben, denen sich Verhalten leicht hinzufügen oder entfernen lässt.
Elixir bietet mehrere Funktionsklauseln und Guards, um Folgendes zu schreiben:
def number(n) when n == 7 do
"Awesome, that's my favorite"
end
def number(_n) do
"That's not my favorite"
end
Zur Laufzeit prüft Elixir von oben nach unten in der Quelldatei, welche Funktionsklausel aufgerufen wird.
Variablen, die nicht verwendet werden, sollten mit einem Unterstrich beginnen.
Guards
Mit Guards verhinderst du, dass Elixir eine Funktion aufruft, wenn die Auswertung der Argumente durch die Guard-Funktionen fehlschlägt. Guards beginnen mit dem Schlüsselwort when, gefolgt von einem booleschen Ausdruck. Guard-Funktionen sind spezielle Funktionen, die:
- pur sein müssen und keine globalen Zustände verändern dürfen.
- ausschließlich
true oder false zurückgeben müssen.
Eine Liste der gängigen Guards findest du in der Elixir-Dokumentation. Sie umfasst Typprüfungen, einfache Arithmetik, Vergleiche und strikt boolesche Operatoren.
Standardargumente
Funktionen können für ein oder mehrere Argumente Standardwerte angeben. Schauen wir uns diese Funktion an:
def number(n \\ 13), do: "That's not my favorite"
Beim Kompilieren erzeugt Elixir eine Funktionsdefinition für number/0 (keine Argumente) und number/1 (ein Argument).
Haben mehr als ein Argument einen Standardwert, werden die Standardwerte von links nach rechts angewendet, um fehlende Argumente zu füllen.
Hat die Funktion mehr als eine Klausel, sollten die Standardargumente in einem Funktionskopf (einer Funktion ohne Rumpf) vor den Funktionsklauseln definiert werden:
def number(n \\ 13)
def number(n) when n < 10, do: "Dream bigger!"
def number(n) when n > 100, do: "Not that big..."
Anleitung
Du erstellst ein einfaches Online-Spiel, bei dem ein Freund eine geheime Zahl erraten kann. Du möchtest etwas Feedback geben, aber die Antwort nicht schon mit einer Vermutung verraten. Du brauchst eine Funktion, die je nachdem, wie die Vermutung zur geheimen Zahl steht, unterschiedliche Antworten liefert.
| Bedingung |
Antwort |
| Wenn die Vermutung mit der geheimen Zahl übereinstimmt |
"Correct" |
| Wenn die Vermutung um eins größer oder eins kleiner als die geheime Zahl ist |
"So close" |
| Wenn die Vermutung größer als die geheime Zahl ist |
"Too high" |
| Wenn die Vermutung kleiner als die geheime Zahl ist |
"Too low" |
| Wenn keine Vermutung abgegeben wird |
"Make a guess" |
Alle Vermutungen und geheimen Zahlen sind Ganzzahlen.
1. Erzeuge die Antwort, wenn die Vermutung mit der geheimen Zahl übereinstimmt
Implementiere die Funktion compare/2, die zwei Argumente entgegennimmt, secret_number und guess, die beide Ganzzahlen sind.
GuessingGame.compare(5, 5)
# => "Correct"
2. Erzeuge die Antwort, wenn die Vermutung größer als die geheime Zahl ist
Passe die Funktion compare an, damit sie auf Vermutungen reagiert, die größer als die geheime Zahl sind.
GuessingGame.compare(5, 8)
# => "Too high"
3. Erzeuge die Antwort, wenn die Vermutung kleiner als die geheime Zahl ist
Passe die Funktion compare an, damit sie auf Vermutungen reagiert, die kleiner als die geheime Zahl sind.
GuessingGame.compare(5, 2)
# => "Too low"
4. Erzeuge die Antworten, wenn die Vermutung um eins größer oder eins kleiner als die geheime Zahl ist
Passe die Funktion compare an, damit sie auf Vermutungen reagiert, die nahe an der geheimen Zahl liegen.
GuessingGame.compare(5, 6)
# => "So close"
GuessingGame.compare(5, 4)
# => "So close"
5. Erzeuge die Antwort, wenn es keine Vermutung gibt
Passe die Funktion compare an, damit sie reagiert, wenn keine Vermutung abgegeben wird.
GuessingGame.compare(5)
# => "Make a guess"
GuessingGame.compare(5, :no_guess)
# => "Make a guess"
Lernübung
