EMZETT.
Login

Emzett Wiki

Erlang: Funktionen und Mustervergleich

Properties1
tagsprogrammiersprachen, erlang

3 Min. Lesezeit

Kurz: Eine Funktion besteht aus Klauseln, die von oben nach unten per Mustervergleich geprüft werden. Klauseln werden mit ; getrennt:

Teil des Kurses Erlang

Kapitel 2 von 8 im Kurs Erlang. Mit Fortschritt, Quiz und Zertifikat auf der Lernseite.

Funktionen mit mehreren Klauseln

Eine Funktion besteht aus Klauseln, die von oben nach unten per Mustervergleich geprüft werden. Klauseln werden mit ; getrennt:

-export([main/1]).
 
fak(0) -> 1;
fak(N) when N > 0 -> N * fak(N - 1).
 
vorzeichen(N) when N > 0 -> positiv;
vorzeichen(N) when N < 0 -> negativ;
vorzeichen(0) -> null.
 
flaeche({kreis, R}) -> math:pi() * R * R;
flaeche({rechteck, B, H}) -> B * H;
flaeche({quadrat, S}) -> S * S.
 
begruesse(Name) -> begruesse(Name, "Hallo").
begruesse(Name, Gruss) -> Gruss ++ ", " ++ Name ++ "!".
 
main(_) ->
    io:format("~p~n", [fak(10)]),
    io:format("~p ~p ~p~n", [vorzeichen(5), vorzeichen(-2), vorzeichen(0)]),
    io:format("~.2f ~p ~p~n", [flaeche({kreis, 1}), flaeche({rechteck, 3, 4}), flaeche({quadrat, 5})]),
    io:format("~s~n", [begruesse("Mia")]),
    io:format("~s~n", [begruesse("Tom", "Servus")]).

Ausgabe:

3628800
positiv negativ null
3.14 12 25
Hallo, Mia!
Servus, Tom!

Die Funktion fak/1 wird mit Name und Stelligkeit bezeichnet (fak/1). begruesse/1 und begruesse/2 sind verschiedene Funktionen. Wächter (when) verfeinern Muster um Bedingungen.

Bedingungen: if, case und Wächter

main(_) ->
    N = 15,
    Text = case {N rem 3, N rem 5} of
        {0, 0} -> "FizzBuzz";
        {0, _} -> "Fizz";
        {_, 0} -> "Buzz";
        _ -> integer_to_list(N)
    end,
    io:format("~s~n", [Text]),
 
    Gross = if N > 10 -> groß; true -> klein end,
    io:format("~p~n", [Gross]),
 
    Pruefe = fun(X) when is_integer(X), X > 0 -> positiv;
                (X) when is_integer(X) -> nicht_positiv;
                (_) -> kein_integer
             end,
    io:format("~p ~p ~p~n", [Pruefe(5), Pruefe(-1), Pruefe(a)]),
 
    io:format("~p~n", [case [1, 2, 3] of [_, Zweites | _] -> Zweites end]),
    io:format("~p~n", [(1 < 2) andalso (2 < 3)]),
    io:format("~p~n", [(1 > 2) orelse (2 < 3)]),
    io:format("~p~n", [not false]),
    io:format("~p~n", [1 =:= 1.0]),
    io:format("~p~n", [1 == 1.0]),
    io:format("~p~n", [1 =/= 2]).

Ausgabe:

FizzBuzz
gro�
positiv nicht_positiv kein_integer
2
true
true
true
false
true
true

Hinweis

== vergleicht Werte (1 == 1.0 ist wahr), =:= vergleicht exakt (1 =:= 1.0 ist falsch). if benötigt immer einen Zweig mit true.

Anonyme Funktionen (Funs)

main(_) ->
    Verdopple = fun(X) -> X * 2 end,
    Addiere = fun(A, B) -> A + B end,
    io:format("~p ~p~n", [Verdopple(21), Addiere(3, 4)]),
 
    Fak = fun F(0) -> 1; F(N) -> N * F(N - 1) end,
    io:format("~p~n", [Fak(10)]),
 
    Anwenden = fun(F, X) -> F(F(X)) end,
    io:format("~p~n", [Anwenden(Verdopple, 5)]),
 
    Addierer = fun(N) -> fun(X) -> X + N end end,
    Plus10 = Addierer(10),
    io:format("~p~n", [Plus10(5)]),
 
    io:format("~p~n", [lists:map(fun erlang:abs/1, [-1, 2, -3])]),
    io:format("~p~n", [lists:map(fun(X) -> X * X end, [1, 2, 3, 4])]),
    io:format("~p~n", [(fun lists:reverse/1)([1, 2, 3])]).

Ausgabe:

42 7
3628800
20
15
[1,2,3]
[1,4,9,16]
[3,2,1]

Merke

  • Funktionen werden durch Mustervergleich in mehreren Klauseln definiert (; trennt, . beendet)
  • Wächter (when) fügen Bedingungen hinzu; case und if verzweigen
  • == vergleicht Werte, =:= exakt
  • Funs sind anonyme Funktionen und Closures; fun name/arity verweist auf benannte Funktionen

Übungsaufgabe

Schreibe fib/1 mit mehreren Klauseln und gib die ersten zehn Fibonacci-Zahlen aus.

Quiz zur Selbstkontrolle

Weiter im Kurs

Zurück: Einführung und erstes Programm

Weiter: Listen, Tupel, Maps und Records

Alle Kapitel: Erlang im Überblick

Graphansicht

Backlinks