EMZETT.
Login

Emzett Wiki

Erlang: Listen, Tupel, Maps und Records

Properties1
tagsprogrammiersprachen, erlang

4 Min. Lesezeit

Kurz: Listenbeschreibungen erzeugen Listen kompakt:

Teil des Kurses Erlang

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

Listen

main(_) ->
    L = [5, 3, 9, 1, 7],
    io:format("~p ~p ~p~n", [length(L), hd(L), tl(L)]),
    io:format("~p~n", [[0 | L]]),
    io:format("~p~n", [L ++ [8, 9]]),
    io:format("~p~n", [lists:reverse(L)]),
    io:format("~p~n", [lists:sort(L)]),
    io:format("~p~n", [lists:sort(fun(A, B) -> A >= B end, L)]),
    io:format("~p~n", [lists:map(fun(X) -> X * 2 end, L)]),
    io:format("~p~n", [lists:filter(fun(X) -> X > 4 end, L)]),
    io:format("~p~n", [lists:foldl(fun(X, Acc) -> X + Acc end, 0, L)]),
    io:format("~p ~p~n", [lists:sum(L), lists:max(L)]),
    io:format("~p~n", [lists:nth(2, L)]),
    io:format("~p~n", [lists:member(9, L)]),
    io:format("~p~n", [lists:seq(1, 5)]),
    io:format("~p~n", [lists:split(2, L)]),
    io:format("~p~n", [lists:sublist(L, 2, 3)]),
    io:format("~p~n", [lists:zip([1, 2, 3], [a, b, c])]),
    io:format("~p~n", [lists:flatten([1, [2, [3, 4]], 5])]),
    io:format("~p~n", [lists:partition(fun(X) -> X rem 2 =:= 0 end, [1, 2, 3, 4, 5])]),
    io:format("~p~n", [lists:any(fun(X) -> X > 8 end, L)]),
    io:format("~p~n", [lists:all(fun(X) -> X > 0 end, L)]),
    io:format("~p~n", [lists:duplicate(3, x)]),
    io:format("~p~n", [lists:usort([3, 1, 2, 3, 1])]),
    io:format("~p~n", [L -- [3, 9]]),
    io:format("~p~n", [lists:keyfind(b, 1, [{a, 1}, {b, 2}])]),
    io:format("~p~n", [lists:last(L)]).

Ausgabe:

5 5 [3,9,1,7]
[0,5,3,9,1,7]
[5,3,9,1,7,8,9]
[7,1,9,3,5]
[1,3,5,7,9]
[9,7,5,3,1]
[10,6,18,2,14]
[5,9,7]
25
25 9
3
true
[1,2,3,4,5]
{[5,3],[9,1,7]}
[3,9,1]
[{1,a},{2,b},{3,c}]
[1,2,3,4,5]
{[2,4],[1,3,5]}
true
true
[x,x,x]
[1,2,3]
[5,1,7]
{b,2}
7

List Comprehensions

Listenbeschreibungen erzeugen Listen kompakt:

main(_) ->
    io:format("~p~n", [[X * X || X <- lists:seq(1, 6)]]),
    io:format("~p~n", [[X || X <- lists:seq(1, 10), X rem 2 =:= 0]]),
    io:format("~p~n", [[{X, Y} || X <- [1, 2], Y <- [a, b]]]),
    io:format("~p~n", [[X + Y || {X, Y} <- [{1, 2}, {3, 4}]]]),
    io:format("~p~n", [[{A, B, C} || C <- lists:seq(1, 20), B <- lists:seq(1, C), A <- lists:seq(1, B), A * A + B * B =:= C * C]]),
    io:format("~p~n", [[string:to_upper(S) || S <- ["ab", "cd"]]]),
    io:format("~p~n", [<< <<(X * 2)>> || <<X>> <= <<1, 2, 3>> >>]).

Ausgabe:

[1,4,9,16,25,36]
[2,4,6,8,10]
[{1,a},{1,b},{2,a},{2,b}]
[3,7]
[{3,4,5},{6,8,10},{5,12,13},{9,12,15},{8,15,17},{12,16,20}]
["AB","CD"]
<<2,4,6>>

Tupel

Tupel haben feste Größe; das erste Element ist oft ein Atom als „Tag“:

main(_) ->
    P = {person, "Mia", 17},
    {person, Name, Alter} = P,
    io:format("~s ~p~n", [Name, Alter]),
    io:format("~p ~p~n", [element(2, P), tuple_size(P)]),
    P2 = setelement(3, P, 18),
    io:format("~p~n", [P2]),
    io:format("~p~n", [tuple_to_list({a, b, c})]),
    io:format("~p~n", [list_to_tuple([1, 2, 3])]),
    Ergebnis = {ok, 42},
    case Ergebnis of
        {ok, V} -> io:format("Erfolg ~p~n", [V]);
        {error, Grund} -> io:format("Fehler ~p~n", [Grund])
    end.

Ausgabe:

Mia 17
"Mia" 3
{person,"Mia",18}
[a,b,c]
{1,2,3}
Erfolg 42

Maps

main(_) ->
    M = #{name => "Mia", alter => 17},
    io:format("~p~n", [maps:get(name, M)]),
    io:format("~p~n", [maps:get(stadt, M, unbekannt)]),
    M2 = M#{alter := 18, stadt => "Berlin"},
    io:format("~p~n", [maps:size(M2)]),
    io:format("~p~n", [lists:sort(maps:keys(M2))]),
    io:format("~p~n", [maps:is_key(stadt, M2)]),
    io:format("~p~n", [maps:to_list(maps:remove(stadt, M2))]),
    #{alter := A} = M2,
    io:format("~p~n", [A]),
    io:format("~p~n", [maps:fold(fun(_, V, Acc) when is_integer(V) -> Acc + V; (_, _, Acc) -> Acc end, 0, M2)]),
    Zaehler = lists:foldl(fun(C, Acc) -> maps:update_with(C, fun(N) -> N + 1 end, 1, Acc) end, #{}, "mississippi"),
    io:format("~p~n", [lists:sort(maps:to_list(Zaehler))]),
    io:format("~p~n", [maps:from_list([{a, 1}, {b, 2}])]),
    io:format("~p~n", [maps:map(fun(_, V) -> V * 10 end, #{x => 1, y => 2})]),
    io:format("~p~n", [maps:filter(fun(_, V) -> V > 1 end, #{x => 1, y => 2})]).

Ausgabe:

"Mia"
unbekannt
3
[alter,name,stadt]
true
[{alter,18},{name,"Mia"}]
18
18
[{105,4},{109,1},{112,2},{115,4}]
#{a => 1,b => 2}
#{x => 10,y => 20}
#{y => 2}

Records

Records geben Tupel-Feldern Namen (zur Übersetzungszeit):

-record(person, {name, alter = 0, hobbys = []}).
 
main(_) ->
    P = #person{name = "Mia", alter = 17},
    io:format("~s ~p~n", [P#person.name, P#person.alter]),
    P2 = P#person{alter = 18, hobbys = ["Lesen"]},
    io:format("~p~n", [P2#person.hobbys]),
    #person{name = N} = P2,
    io:format("~s~n", [N]),
    io:format("~p~n", [is_record(P, person)]),
    io:format("~p~n", [P]).

Ausgabe:

Mia 17
["Lesen"]
Mia
true
{person,"Mia",17,[]}

Merke

  • Listen: lists-Modul mit map, filter, foldl, sort, seq, zip; hd/tl, ++, --
  • List Comprehensions [Ausdruck || Muster <- Liste, Bedingung]
  • Tupel bündeln feste Daten; Records geben Feldern Namen; Maps sind Schlüssel-Wert-Tabellen
  • Maps aktualisiert man mit M#{k := v} (vorhandener Schlüssel) oder M#{k => v} (neu oder bestehend)

Übungsaufgabe

Zähle mit einer Map die Wörter eines Satzes.

Quiz zur Selbstkontrolle

]?

  • [2,4,6] (richtig)
  • [1,2,3]
  • 6
  • Einen Fehler

Weiter im Kurs

Zurück: Funktionen und Mustervergleich

Weiter: Rekursion, Strings und Binaries

Alle Kapitel: Erlang im Überblick

Graphansicht

Backlinks