EMZETT.
Login

Emzett Wiki

Erlang: Rekursion, Strings und Binaries

Properties1
tagsprogrammiersprachen, erlang

4 Min. Lesezeit

Kurz: Schleifen gibt es nicht – Rekursion ersetzt sie. Endrekursion (der Aufruf ist die letzte Aktion) verbraucht keinen Stack:

Teil des Kurses Erlang

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

Rekursion

Schleifen gibt es nicht – Rekursion ersetzt sie. Endrekursion (der Aufruf ist die letzte Aktion) verbraucht keinen Stack:

summe([]) -> 0;
summe([K | R]) -> K + summe(R).
 
laenge(L) -> laenge(L, 0).
laenge([], N) -> N;
laenge([_ | R], N) -> laenge(R, N + 1).
 
mein_map(_, []) -> [];
mein_map(F, [K | R]) -> [F(K) | mein_map(F, R)].
 
fib(N) -> fib(N, 0, 1).
fib(0, A, _) -> A;
fib(N, A, B) -> fib(N - 1, B, A + B).
 
ggt(A, 0) -> A;
ggt(A, B) -> ggt(B, A rem B).
 
zaehle(0) -> fertig;
zaehle(N) -> zaehle(N - 1).
 
hanoi(0, _, _, _) -> [];
hanoi(N, Von, Nach, Hilf) ->
    hanoi(N - 1, Von, Hilf, Nach) ++ [{N, Von, Nach}] ++ hanoi(N - 1, Hilf, Nach, Von).
 
main(_) ->
    io:format("~p~n", [summe([1, 2, 3, 4])]),
    io:format("~p~n", [laenge([a, b, c])]),
    io:format("~p~n", [mein_map(fun(X) -> X + 1 end, [1, 2, 3])]),
    io:format("~p~n", [fib(90)]),
    io:format("~p~n", [ggt(48, 18)]),
    io:format("~p~n", [zaehle(1000000)]),
    io:format("~p~n", [hanoi(3, links, rechts, mitte)]).

Ausgabe:

10
3
[2,3,4]
2880067194370816120
6
fertig
[{1,links,rechts},
 {2,links,mitte},
 {1,rechts,mitte},
 {3,links,rechts},
 {1,mitte,links},
 {2,mitte,rechts},
 {1,links,rechts}]

Strings

In Erlang sind Strings Listen von Zeichencodes. Für Text gibt es das Modul string und Binaries:

main(_) ->
    S = "Hallo Erlang",
    io:format("~p~n", [S]),
    io:format("~p~n", [length(S)]),
    io:format("~p~n", [string:to_upper(S)]),
    io:format("~p~n", [string:substr(S, 7, 6)]),
    io:format("~p~n", [string:tokens("a,b,,c", ",")]),
    io:format("~p~n", [string:split("a,b,c", ",", all)]),
    io:format("~p~n", [string:join(["x", "y", "z"], "-")]),
    io:format("~p~n", [string:trim("  mitte  ")]),
    io:format("~p~n", [string:find(S, "Erl")]),
    io:format("~p~n", [string:replace("a-b-c", "-", "+", all)]),
    io:format("~p~n", [lists:flatten(io_lib:format("~p-~s-~.2f", [1, "x", 3.14159]))]),
    io:format("~p~n", [S ++ "!"]),
    io:format("~p~n", [lists:reverse(S)]),
    io:format("~p~n", [string:equal("a", "A", true)]),
    io:format("~p~n", [list_to_integer("42") + 1]),
    io:format("~p~n", [integer_to_list(255)]),
    io:format("~p~n", [float_to_list(2.5, [{decimals, 1}])]),
    io:format("~p~n", [[C - 32 || C <- "abc"]]),
    io:format("~p~n", [string:length("äöü")]),
    io:format("~ts~n", ["Umlaute: äöü"]),
    io:format("~p~n", [re:run("abc123def", "[0-9]+", [{capture, first, list}])]),
    io:format("~p~n", [re:replace("Hallo", "[aeiou]", "*", [global, {return, list}])]),
    io:format("~p~n", [string:titlecase("wort")]),
    io:format("~p~n", [string:lowercase("ABC")]).

Ausgabe:

"Hallo Erlang"
12
"HALLO ERLANG"
"Erlang"
["a","b","c"]
["a","b","c"]
"x-y-z"
"mitte"
"Erlang"
["a","+","b","+","c"]
"1-x-3.14"
"Hallo Erlang!"
"gnalrE ollaH"
true
43
"255"
"2.5"
"ABC"
3
Umlaute: ���
{match,["123"]}
"H*ll*"
"Wort"
"abc"

Binaries und Bitsyntax

Eine Stärke von Erlang: Bit-genaue Muster für Protokolle und Dateiformate:

main(_) ->
    B = <<"Hallo">>,
    io:format("~p ~p~n", [byte_size(B), binary_to_list(B)]),
    io:format("~p~n", [<<B/binary, " Welt">>]),
    io:format("~p~n", [binary:split(<<"a,b,c">>, <<",">>, [global])]),
    io:format("~p~n", [binary:part(B, 1, 3)]),
    io:format("~p~n", [binary_to_integer(<<"42">>) + 1]),
    io:format("~p~n", [list_to_binary([72, 105])]),
    io:format("~p~n", [unicode:characters_to_binary("äöü")]),
 
    <<R:8, G:8, Bl:8>> = <<255, 128, 0>>,
    io:format("~p ~p ~p~n", [R, G, Bl]),
    Header = <<1:4, 5:4, 200:8, 1000:16>>,
    io:format("~p~n", [Header]),
    <<Version:4, Laenge:4, Typ:8, Port:16>> = Header,
    io:format("~p ~p ~p ~p~n", [Version, Laenge, Typ, Port]),
    <<Kopf:2/binary, Rest/binary>> = <<"ABCDEF">>,
    io:format("~p ~p~n", [Kopf, Rest]),
    io:format("~p~n", [<< <<X:8>> || X <- [1, 2, 3] >>]),
    io:format("~p~n", [binary:decode_unsigned(<<1, 0>>)]),
    io:format("~p~n", [binary:encode_unsigned(258)]),
    io:format("~p~n", [crypto:hash(md5, "a") =/= <<>>]).

Ausgabe:

5 "Hallo"
<<"Hallo Welt">>
[<<"a">>,<<"b">>,<<"c">>]
<<"all">>
43
<<"Hi">>
<<"äöü">>
255 128 0
<<21,200,3,232>>
1 5 200 1000
<<"AB">> <<"CDEF">>
<<1,2,3>>
256
<<1,2>>
true

Merke

  • Rekursion ersetzt Schleifen; Akkumulatoren machen Aufrufe endrekursiv
  • Strings sind Listen von Zeichencodes; das Modul string bietet Funktionen
  • Binaries (<<...>>) und Bitsyntax parsen und bauen Protokolle bit-genau
  • Mit ~ts gibt io:format Unicode aus

Übungsaufgabe

Schreibe palindrom/1 für Strings und teste “anna”.

Quiz zur Selbstkontrolle

Weiter im Kurs

Zurück: Listen, Tupel, Maps und Records

Weiter: Prozesse und Nachrichten

Alle Kapitel: Erlang im Überblick

Graphansicht

Backlinks