EMZETT.
Login

Emzett Wiki

Erlang: Einführung und erstes Programm

Properties1
tagsprogrammiersprachen, erlang

4 Min. Lesezeit

Kurz: Erlang (1986, Ericsson) wurde für Telefonvermittlungen entworfen: Systeme, die nie ausfallen dürfen, Millionen gleichzeitiger Verbindungen verwalten und sich im laufenden Betrieb aktualisieren lassen.

Teil des Kurses Erlang

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

Was ist Erlang?

Erlang (1986, Ericsson) wurde für Telefonvermittlungen entworfen: Systeme, die nie ausfallen dürfen, Millionen gleichzeitiger Verbindungen verwalten und sich im laufenden Betrieb aktualisieren lassen. Die Sprache ist funktional, dynamisch typisiert und baut auf leichtgewichtigen Prozessen auf, die ausschließlich über Nachrichten kommunizieren (Actor-Modell). Fehlerbehandlung folgt dem Motto „Let it crash“: Supervisor-Prozesse starten abgestürzte Prozesse neu.

Erlang läuft auf der virtuellen Maschine BEAM, auf der auch Elixir basiert. Eingesetzt wird es von WhatsApp, RabbitMQ, CouchDB, Ericsson, Discord (teilweise) und vielen Banken.

Ausführen

escript hallo.escript         # Skript ausführen (wie in diesem Kurs)
erl                            # interaktive Shell: 1> io:format("Hallo~n").
erlc modul.erl                 # Modul übersetzen
erl -noshell -s modul start -s init stop
rebar3 new app meinapp         # Projektgerüst
rebar3 shell                   # Shell mit geladenem Projekt

In diesem Kurs laufen die Beispiele als escript: Das Skript enthält Funktionen und eine Einstiegsfunktion main/1.

Das erste Programm

main(_) ->
    io:format("Hallo, Welt!~n"),
    io:format("1 + 2 = ~p~n", [1 + 2]),
    io:format("~s hat ~w Punkte~n", ["Mia", 17]),
    io:put_chars("ohne Zeilenumbruch"),
    io:nl(),
    X = 42,
    io:format("X = ~p~n", [X]).

Ausgabe:

Hallo, Welt!
1 + 2 = 3
Mia hat 17 Punkte
ohne Zeilenumbruch
X = 42

Jede Anweisung endet mit ,, die letzte einer Funktion mit .. io:format formatiert mit ~p (hübsch), ~w (roh), ~s (String), ~n (Zeilenumbruch), ~B (Ganzzahl) und ~f (Fließkommazahl).

Variablen sind einmal bindbar

Variablen beginnen mit einem Großbuchstaben und lassen sich nur einmal zuweisen (single assignment). = ist ein Mustervergleich:

main(_) ->
    X = 5,
    Y = X * 2,
    io:format("~p ~p~n", [X, Y]),
    {A, B} = {1, 2},
    io:format("~p ~p~n", [A, B]),
    [Kopf | Rest] = [1, 2, 3],
    io:format("~p ~p~n", [Kopf, Rest]),
    {ok, Wert} = {ok, 99},
    io:format("~p~n", [Wert]),
    X = 5,                            % passt: X ist bereits 5
    io:format("Muster passt~n"),
    try
        X = 6
    catch
        error:{badmatch, V} -> io:format("badmatch ~p~n", [V])
    end.

Ausgabe:

5 10
1 2
1 [2,3]
99
Muster passt
badmatch 6

Datentypen im Überblick

main(_) ->
    io:format("~p~n", [42]),                       % Ganzzahl (beliebig groß)
    io:format("~p~n", [3.14]),                     % Fließkommazahl
    io:format("~p~n", [atom]),                     % Atom (Konstante, klein geschrieben)
    io:format("~p~n", ['Atom mit Leerzeichen']),
    io:format("~p~n", [true]),                     % true/false sind Atome
    io:format("~p~n", [{punkt, 1, 2}]),            % Tupel
    io:format("~p~n", [[1, 2, 3]]),                % Liste
    io:format("~p~n", ["Text"]),                   % String = Liste von Zeichencodes
    io:format("~p~n", [<<"Binary">>]),             % Binary
    io:format("~p~n", [#{a => 1, b => 2}]),        % Map
    io:format("~p~n", [fun(X) -> X * 2 end(21)]),
    io:format("~p ~p~n", [is_integer(5), is_atom(hallo)]),
    io:format("~p~n", [2 bsl 3]),
    io:format("~p~n", [math:pow(2, 10)]),
    io:format("~p~n", [7 div 2]),
    io:format("~p ~p~n", [7 rem 3, -7 rem 3]),
    io:format("~p~n", [7 / 2]),
    io:format("~p~n", [round(2.5)]),
    io:format("~p~n", [erlang:integer_to_list(255, 16)]),
    io:format("~p~n", [list_to_integer("42") + 1]),
    io:format("~p~n", [2#1010 + 16#FF]),
    io:format("~p~n", [trunc(-3.7)]),
    io:format("~p~n", [math:pi()]).

Ausgabe:

42
3.14
atom
'Atom mit Leerzeichen'
true
{punkt,1,2}
[1,2,3]
"Text"
<<"Binary">>
#{a => 1,b => 2}
42
true true
16
1024.0
3
1 -1
3.5
3
"FF"
43
265
-3
3.141592653589793

Merke

  • Erlang ist funktional, dynamisch typisiert und läuft auf der BEAM
  • Variablen (Großbuchstabe) sind einmal bindbar; = ist ein Mustervergleich
  • Atome, Tupel, Listen, Maps, Binaries; Strings sind Listen von Zeichencodes
  • Anweisungen enden mit ,, Funktionen mit .

Übungsaufgabe

Gib den Flächeninhalt eines Rechtecks aus, dessen Seiten als Tupel {3, 4} gegeben sind.

Quiz zur Selbstkontrolle

Weiter im Kurs

Weiter: Funktionen und Mustervergleich

Alle Kapitel: Erlang im Überblick

Graphansicht

Backlinks