Erlang Language
Datatyper

Anmärkningar

Tal

I Erlang är siffrorna antingen heltal eller flottörer. Erlang använder godtycklig precision för heltal (bignums), så deras värden begränsas endast av minnesstorleken på ditt system.

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

Siffror kan användas i olika baser:

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

Notering av $ -prefix ger heltal för ASCII / Unicode-tecken:

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

Atoms

En atom är ett objekt med ett namn som bara identifieras av själva namnet.

Atomer definieras i Erlang med hjälp av atomlitteraler som är antingen

• en ociterad sträng som börjar med en liten bokstav och endast innehåller bokstäver, siffror, understreck eller @ -tecknet, eller
• En enda citerad sträng

exempel

1> hello.
hello

2> hello_world.
hello_world

3> world_Hello@.
world_Hello@

4> '1234'.     
'1234'

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

Atomer som används i de flesta Erlang-program

Det finns några atomer som finns i nästan alla Erlang-program, särskilt på grund av deras användning i Standardbiblioteket.

• true och false används för att beteckna respektive booleska värden
• ok används vanligtvis som ett returvärde för en funktion som bara kallas för dess effekt, eller som en del av ett returvärde, i båda fallen för att beteckna ett framgångsrikt utförande
• På samma sätt används error för att indikera ett feltillstånd som inte garanterar en tidig återkomst från de övre funktionerna
• undefined används vanligtvis som en platshållare för ett ospecificerat värde

Använd som taggar

ok och error används ganska ofta som en del av en tupel, där det första elementet i tupeln signalerar framgång medan ytterligare element innehåller det faktiska returvärdet eller feltillståndet:

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

{ok, _} = func(SomeValue).

Lagring

En sak att tänka på när man använder atomer är att de lagras i sin egen globala tabell i minnet och denna tabell är inte skräp som samlas in, så dynamiskt skapar atomer, särskilt när en användare kan påverka atomnamnet är starkt avskräckt.

Binärer och bitsträngar

En binär är en sekvens av osignerade 8-bitarsbyte.

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

En bitsträng är en generaliserad binär vars längd i bitar inte nödvändigtvis är en multipel av 8.

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

tupler

En tupel är en ordnad sekvens av bestämd längd för andra Erlang-termer. Varje element i tupeln kan vara vilken typ av term som helst (vilken datatyp som helst).

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]}}

listor

En lista i Erlang är en sekvens med noll eller fler Erlang-termer, implementerade som en enskilt länkad lista. Varje element i listan kan vara vilken som helst typ av term (vilken datatyp som helst).

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

Listans huvud är det första elementet i listan.

Listans svans är resten av listan (utan huvudet). Det är också en lista.
Du kan använda hd/1 och tl/1 eller matcha mot [H|T] att få listans huvud och svans.

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]

Förbereda ett element i en lista

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

Slå samman listor

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

strängar

I Erlang är strängar inte en separat datatyp: de är bara listor med heltal som representerar ASCII- eller Unicode-kodpunkter:

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

När Erlang-skalet ska skriva ut en lista försöker det gissa om du egentligen menade att det skulle vara en sträng. Du kan stänga av det beteendet genom att ringa shell:strings(false) :

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

I exemplet ovan tolkas heltalet 8 som ASCII-kontrolltecken för backspace, vilket skalet anser vara ett "giltigt" tecken i en sträng.

Processer-identifierare (Pid)

Varje process i erlang har en processidentifierare ( Pid ) i detta format <xxx> , x är ett naturligt tal. Nedan är ett exempel på en Pid

<0.1252.0>

Pid kan användas för att skicka meddelanden till processen med 'bang' ( ! ), Också Pid kan begränsas till en variabel, båda visas nedan

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

Läs mer om att skapa processer och mer generellt om processer i erlang

funs

Erlang är ett funktionellt programmeringsspråk. En av funktionerna i ett programmeringsspråk är att hantera funktioner som data (funktionsobjekt).

• Vidarebefordra en funktion som ett argument till en annan funktion.
• Returfunktion som ett resultat av en funktion.
• Håll funktioner i viss datastruktur.

I Erlang kallas dessa funktioner funs. Besvär är anonyma funktioner.

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

Kämpar kan också ha flera klausuler.

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

Du kan också använda modulfunktioner som funs med syntaxen: fun Module:Function/Arity .
Till exempel, kan ta funktionen max från lists modul, som har ställighet 1.

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

Kartor

En karta är en associerande grupp eller ordbok som består av (nyckel, värde) par.

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

Så här uppdaterar du en karta:

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

Uppdatera bara en befintlig nyckel:

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

Mönstermatchning:

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

Bitsyntax: Standardvärden

Förtydligande av Erlang doc på Bit Syntax:

4.4 Standardvärden

[Början utelämnad: << 3.14 >> är inte ens laglig syntax.]

Standardstorleken beror på typen. För heltal är det 8. För flottör är det 64. För binär är det den verkliga storleken på den angivna binären:

    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

I matchning är ett binärt segment utan storlek endast tillåtet i slutet av mönstret, och standardstorleken är resten av binäret på matchen till höger:

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

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

27> X. 
97

28> Rest. 
<<"bc">>

Alla andra segment med typ binär i ett mönster måste ange en storlek:

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