Erlang Language
Datentypen

Bemerkungen

Zahlen

In Erlang sind Zahlen entweder Ganzzahlen oder Floats. Erlang verwendet für Ganzzahlen (Bignums) eine beliebige Genauigkeit, sodass deren Werte nur durch die Speichergröße Ihres Systems begrenzt sind.

1> 11.
11
2> -44.
-44
3> 0.1.
0.1
4> 5.1e-3.
0.0051
5> 5.2e2.
520.0

Zahlen können in verschiedenen Basen verwendet werden:

1> 2#101.
5
2> 16#ffff.
65535

$ -prefix-Notation liefert den ganzzahligen Wert eines beliebigen ASCII / Unicode-Zeichens:

3> $a.
97
4> $A.
65
5> $2.
50
6> $🤖.
129302

Atome

Ein Atom ist ein Objekt mit einem Namen, der nur durch den Namen selbst identifiziert wird.

Atome werden in Erlang definiert, wobei Atomliterale verwendet werden

• eine Zeichenfolge ohne Anführungszeichen, die mit einem Kleinbuchstaben beginnt und nur Buchstaben, Ziffern, Unterstriche oder das @ -Zeichen enthält, oder
• Eine einzelne Anführungszeichenfolge

Beispiele

1> hello.
hello

2> hello_world.
hello_world

3> world_Hello@.
world_Hello@

4> '1234'.     
'1234'

5> '!@#$%% ä'.
'!@#$%% ä'

Atome, die in den meisten Erlang-Programmen verwendet werden

Es gibt einige Atome, die in fast jedem Erlang-Programm vorkommen, insbesondere wegen ihrer Verwendung in der Standard Library.

• true und false werden verwendet, um die jeweiligen booleschen Werte zu bezeichnen
• ok wird normalerweise als Rückgabewert einer Funktion verwendet, die nur für ihre Wirkung aufgerufen wird, oder als Teil eines Rückgabewerts, in beiden Fällen, um eine erfolgreiche Ausführung zu signalisieren
• Auf dieselbe Weise wird error verwendet, um eine Fehlerbedingung anzuzeigen, die keine frühzeitige Rückkehr von den oberen Funktionen aus rechtfertigt
• undefined wird normalerweise als Platzhalter für einen nicht angegebenen Wert verwendet

Verwenden Sie als Tags

ok und error werden häufig als Teil eines Tupels verwendet, bei dem das erste Element des Tupels Erfolg signalisiert, während weitere Elemente den tatsächlichen Rückgabewert oder die Fehlerbedingung enthalten:

func(Input) ->
    case Input of
        magic_value ->
            {ok, got_it};
        _ ->
            {error, wrong_one}
    end.

{ok, _} = func(SomeValue).

Lager

Bei der Verwendung von Atomen ist zu beachten, dass sie in einer eigenen globalen Tabelle im Speicher abgelegt werden und diese Tabelle nicht als Müll gesammelt wird. Dadurch werden Atome dynamisch erzeugt, insbesondere wenn ein Benutzer Einfluss auf den Atomnamen hat.

Binaries und Bitstrings

Eine Binärdatei ist eine Folge von vorzeichenlosen 8-Bit-Bytes.

1> <<1,2,3,255>>.
<<1,2,3,255>>
2> <<256,257,258>>.
<<0,1,2>>
3> <<"hello","world">>.
<<"helloworld">>

Eine Bitkette ist eine verallgemeinerte Binärdatei, deren Länge in Bits nicht notwendigerweise ein Vielfaches von 8 ist.

1> <<1:1, 0:2, 1:1>>.
<<9:4>> % 4 bits bitstring

Tuples

Ein Tupel ist eine geordnete Folge von anderen Erlang-Begriffen mit fester Länge. Jedes Element im Tupel kann ein beliebiger Begriff sein (jeder Datentyp).

1> {1, 2, 3}.
{1,2,3}
2> {one, two, three}.
{one,two,three}
3> {mix, atom, 123, {<<1,2>>, [list]}}.
{mix,atom,123,{<<1,2>>,[list]}}

Listen

Eine Liste in Erlang ist eine Folge von null oder mehr Erlang-Begriffen, die als einzeln verknüpfte Liste implementiert ist. Jedes Element in der Liste kann ein beliebiger Begriff sein (jeder Datentyp).

1> [1,2,3].
[1,2,3]
2> [wow,1,{a,b}].     
[wow,1,{a,b}]

Der Kopf der Liste ist das erste Element der Liste.

Das Ende der Liste ist der Rest der Liste (ohne den Kopf). Es ist auch eine Liste.
Sie können hd/1 und tl/1 oder mit [H|T] hd/1 , um Kopf und Ende der Liste zu erhalten.

3> hd([1,2,3]).
1
4> tl([1,2,3]).
[2,3]
5> [H|T] = [1,2,3].
[1,2,3]
6> H.
1
7> T.
[2,3]

Element vor Liste stellen

8> [new | [1,2,3]].
[new,1,2,3]

Listen verketten

9> [concat,this] ++ [to,this].
[concat,this,to,this]

Zeichenketten

In Erlang sind Zeichenfolgen kein separater Datentyp: Sie sind nur Listen von Ganzzahlen, die ASCII- oder Unicode-Codepunkte darstellen:

> [97,98,99].
"abc"
> [97,98,99] =:= "abc".
true
> hd("ABC").
65

Wenn die Erlang-Shell eine Liste druckt, versucht sie zu erraten, ob Sie es eigentlich als Zeichenfolge gemeint haben. Sie können dieses Verhalten deaktivieren, indem Sie shell:strings(false) aufrufen:

> [8].
"\b"
> shell:strings(false).
true
> [8].
[8]

Im obigen Beispiel wird die Ganzzahl 8 als ASCII-Steuerzeichen für die Rücktaste interpretiert, das die Shell als "gültiges" Zeichen in einer Zeichenfolge betrachtet.

Prozesskennungen (PID)

Jeder Prozess in erlang hat eine Prozesskennung ( Pid ) in diesem Format <xxx> , wobei x eine natürliche Zahl ist. Unten ist ein Beispiel für eine Pid

<0.1252.0>

Pid kann verwendet werden, um Nachrichten über 'bang' ( ! ) An den Prozess zu senden. Pid kann auch an eine Variable gebunden werden. Beide werden unten gezeigt

MyProcessId = self().
MyProcessId ! {"Say Hello"}.

Erfahren Sie mehr über das Erstellen von Prozessen und allgemein über Prozesse in Erlang

Funs

Erlang ist eine funktionale Programmiersprache. In einer Funktionsprogrammiersprache werden Funktionen als Daten (Funktionsobjekte) behandelt.

• Übergeben Sie eine Funktion als Argument an eine andere Funktion.
• Funktion als Ergebnis einer Funktion zurückgeben.
• Halte Funktionen in einer Datenstruktur.

In Erlang werden diese Funktionen als Spaß bezeichnet. Funs sind anonyme Funktionen.

1> Fun = fun(X) -> X*X end.
#Fun<erl_eval.6.52032458>
2> Fun(5).
25

Funs können auch mehrere Klauseln enthalten.

3> AddOrMult = fun(add,X) -> X+X;
3>                (mul,X) -> X*X 
3> end.
#Fun<erl_eval.12.52032458>
4> AddOrMult(mul,5).
25
5> AddOrMult(add,5).
10

Sie können Modulfunktionen auch als fun Module:Function/Arity mit der Syntax verwenden: fun Module:Function/Arity .
Nehmen wir zum Beispiel die Funktion max aus dem lists Modul, das die Arity 1 hat.

6> Max = fun lists:max/1.
#Fun<lists.max.1>
7> Max([1,3,5,9,2]). 
9

Karten

Eine Karte ist ein assoziatives Array oder Wörterbuch, das aus (Schlüssel-, Wert-) Paaren besteht.

1> M0 = #{}.
#{}
2> M1 = #{ "name" => "john", "age" => "28" }.
#{"age" => "28","name" => "john"}
3> M2 = #{ a => {M0, M1} }.
#{a => {#{},#{"age" => "28","name" => "john"}}}

So aktualisieren Sie eine Karte:

1> M = #{ 1 => x }.
2> M#{ 1 => c }.
#{1 => c}
3> M.
#{1 => x}

Aktualisieren Sie nur einige vorhandene Schlüssel:

1> M = #{ 1 => a, 2 => b}.
2> M#{ 1 := c, 2:= d }.
#{1 => c,2 => d}
3> M#{ 3 := c }.
** exception error: {badkey,3}

Musterabgleich:

1> M = #{ name => "john", age => 28 }.
2> #{ name := Name, age := Age } = M.
3> Name.
"john"
4> Age.
28

Bitsyntax: Standardwerte

Erläuterung von Erlang doc zur Bitsyntax:

4.4 Standardeinstellungen

[Anfang weggelassen: << 3.14 >> ist nicht einmal eine legale Syntax.]

Die Standardgröße hängt vom Typ ab. Für Ganzzahl ist es 8. Für Float ist es 64. Für Binärgröße ist dies die tatsächliche Größe der angegebenen Binärdatei:

    1> Bin = << 17/integer, 3.2/float, <<97, 98, 99>>/binary >>. 
    <<17,64,9,153,153,153,153,153,154,97,98,99>>
      ^ |<-------------------------->|<------>|
      |            float=64           binary=24
  integer=8


    2> size(Bin). % Returns the number of bytes:
    12            % 8 bits + 64 bits + 3*8 bits = 96 bits => 96/8 = 12 bytes

Beim Matching ist ein binäres Segment ohne Size nur am Ende des Musters zulässig. Die Standardgröße ist der Rest der Binärdatei auf der rechten Seite des Matches.

25> Bin = <<97, 98, 99>>. 
<<"abc">>

26> << X/integer, Rest/binary >> = Bin. 
<<"abc">>

27> X. 
97

28> Rest. 
<<"bc">>

Alle anderen Segmente mit dem Typ binär in einem Muster müssen eine Größe angeben:

12> Bin = <<97, 98, 99, 100>>.         
<<"abcd">>

13> << B:1/binary, X/integer, Rest/binary >> = Bin. %'unit' defaults to 8 for  
<<"abcd">>                    %binary type, total segment size is Size * unit  

14> B.
<<"a">>

15> X.
98

16> Rest.
<<"cd">>

17> << B2/binary, X2/integer, Rest2/binary >> = Bin. 
* 1: a binary field without size is only allowed at the end of a binary pattern