Erlang Language Handledning
Komma igång med Erlang Language

Anmärkningar

versioner

Hej världen

Det finns två saker du behöver veta när du skriver en "hej värld" -applikation i Erlang:

1. Källkoden skrivs på erlangs programmeringsspråk med den textredigerare du väljer
2. Applikationen körs sedan i den virtuella erlang maskin . I det här exemplet kommer vi att interagera med erlang VM genom erlangskalet.

Först applikationens källkod:

Skapa en ny fil hello.erl innehåller följande:

-module(hello).
-export([hello_world/0]).

hello_world() ->
  io:format("Hello, World!~n", []).

Låt oss titta snabbt på vad det här betyder:

• -module(hello). Alla erlang-funktioner finns i en modul . Moduler används sedan för att bygga applikationer, som är en samling moduler. Den här första raden är att identifiera denna modul, nämligen hej . Moduler kan jämföras med Javas paket
• -export([hello_world/0]). Berättar kompilatorn som fungerar för att göra "offentlig" (jämfört med OO-språk) och ariten för den relevanta funktionen. Arity är antalet argument som funktionen tar. Eftersom i erlang en funktion med 1 argument ses som en annan funktion än en med 2 argument även om namnet kan vara exakt samma. Dvs hello_world/0 är en helt annan funktion än till exempel hello_world/1 .
• hello_world() Detta är namnet på funktionen. Den -> indikerar övergången till implementeringen (kroppen) av funktionen. Detta kan läsas som "hello_world () definieras som ...". Observera att hello_world() (inga argument) identifieras av hello_world/0 i VM, och hello_world(Some_Arg) som hello_world/1 .
• io:format("Hello, World!~n", []) Från modul io kallas funktionsformatet format/2 funktionen, vilket är funktionen för standardutgång. ~n är en formatspecifikation som betyder att skriva ut en ny rad. [] Är en lista med variabler som ska skrivas ut indikerade med formatspecifikationer i utgångssträngen, vilket i detta fall inte är något.
• Alla erlang uttalanden måste sluta med a . (punkt).

I Erlang returneras resultatet av det sista uttalandet i en funktion.

Låt oss nu köra vår ansökan:

Starta erlangs skal från samma katalog som filen hello.erl :

$ erl

Du bör få en fråga som ser ut så här (din version kan vara annorlunda):

Eshell V8.0  (abort with ^G)
1>

Ange nu följande kommandon:

1> c(hello).
{ok,hello}
2> hello:hello_world().
Hello, World!
ok

Låt oss gå igenom varje rad en och en:

• c(hello) - det här kommandot kallar funktionen c på ett atom hello . Detta säger effektivt till Erlang att hitta filen hello.erl , sammanställa den till en modul (en fil som heter hello.beam kommer att genereras i katalogen) och ladda den i miljön.
• {ok, hello} - detta är resultatet av att man kallar funktionen c ovan. Det är en tupel som innehåller en atom ok och en atom hello . Erlang-funktioner returnerar vanligtvis antingen {ok, Something} eller {error, Reason} .
• hello:hello_world() - detta kallar en funktion hello_world() från modulen hello .
• Hello, World! - det här är vad vår funktion skriver ut.
• ok - det här är vad vår funktion returnerade. Eftersom Erlang är ett funktionellt programmeringsspråk returnerar varje funktion något . I vårt fall, även om vi inte returnerade någonting i hello_world() , var det sista samtalet i den funktionen att io:format(...) och den funktionen returnerade ok , vilket i sin tur är vad vår funktion returnerade.

moduler

En erlang-modul är en fil med ett par funktioner grupperade ihop. Denna fil har vanligtvis .erl förlängning.

En "Hello World" -modul med namnet hello.erl visas nedan

-module(hello).
-export([hello_world/0]).

hello_world() ->
  io:format("Hello, World!~n", []).

I filen krävs det att deklarera modulnamnet. Som visas tidigare i rad 1. Modulnamnet och filnamnet före .erl förlängningen måste vara samma.

Fungera

Funktion är en uppsättning instruktioner som är grupperade ihop. Dessa grupperade instruktioner utför tillsammans en viss uppgift. I erlang kommer alla funktioner att returnera ett värde när de anropas.

Nedan är ett exempel på en funktion som lägger till två siffror

add(X, Y)-> X + Y.

Denna funktion utför en tilläggsoperation med X- och Y-värden och returnerar resultatet. Funktionen kan användas enligt nedan

add(2,5).

Funktionsdeklarationer kan bestå av flera klausuler, separerade med en semikolon. Argumenten i vart och ett av dessa klausuler utvärderas genom mönstermatchning. Följande funktion returnerar 'tuple' om Argumentet är en tupel i Form: {test, X} där X kan vara valfritt värde. Den kommer att returnera 'lista', om argumentet är en lista med längden 2 i formen ["test", X], och det kommer att returnera '{error,' Reason '}' i något annat fall:

function({test, X}) -> tuple;
function(["test", X]) -> list;
function(_) -> {error, "Reason"}.

Om argumentet inte är en tupel kommer den andra klausulen att utvärderas. Om argumentet inte är en lista kommer den tredje klausulen att utvärderas.

Funktionsdeklarationer kan bestå av så kallade "vakter" eller "vaktsekvenser". Dessa vakter är uttryck som begränsar utvärderingen av en funktion. En funktion med vakter körs endast när alla Guard Expressions ger ett verkligt värde. Flera vakter kan separeras med en semikolon.

function_name(Argument) when Guard1; Guard2; ... GuardN -> (...).

Funktionen 'funktionsnamn' utvärderas endast när Guard Sequence är sant. Följande funktion kommer att returnera true endast om argumentet X är inom rätt intervall (0..15):

in_range(X) when X>=0; X<16 -> true;
in_range(_) -> false.

Listförståelse

Listförståelser är en syntaktisk konstruktion för att skapa en lista baserad på befintliga listor.
I erlang har en listaförståelse formen [Expr || Qualifier1, ..., QualifierN] .
Där kvalifikationer är antingen generatorer Pattern <- ListExpr eller filter som integer(X) utvärderar till antingen true eller false .

Följande exempel visar en listaförståelse med en generator och två filter.

[X || X <- [1,2,a,3,4,b,5,6], integer(X), X > 3].

Resultatet är en lista som endast innehåller heltal över 3.

[4,5,6]

Starta och stoppa Erlang Shell

Starta Erlang-skalet

På ett UNIX-system startar du Erlang-skalet från en kommandotolk med kommandot erl

Exempel:

$ erl
Erlang/OTP 18 [erts-7.0] [source] [64-bit] [smp:8:8] [async-threads:10] [hipe] [kernel-poll:false]

Eshell V7.0  (abort with ^G)
1> 

Texten som visar när du startar skalet ger dig information om vilken version av Erlang du kör samt annan användbar information om erlangsystemet.

För att starta skalet på Windows klickar du på Erlang-ikonen i Windows-startmenyn.

Stoppa Erlang-skalet

För en kontrollerad utgång från erlangs skalet skriver du:

Erlang/OTP 18 [erts-7.0] [source] [64-bit] [smp:8:8] [async-threads:10] [hipe] [kernel-poll:false]

Eshell V7.0  (abort with ^G)
1> q().

Du kan också avsluta Erlang-skalet genom att trycka på Ctrl + C på UNIX-system eller Ctrl + Break på Windows, vilket leder till följande prompt:

Erlang/OTP 18 [erts-7.0] [source] [64-bit] [smp:8:8] [async-threads:10] [hipe] [kernel-poll:false]

Eshell V7.0  (abort with ^G)
1> 
BREAK: (a)bort (c)ontinue (p)roc info (i)nfo (l)oaded
       (v)ersion (k)ill (D)b-tables (d)istribution

Om du sedan trycker på a (för att avbryta) kommer du att lämna skalet direkt.

Andra sätt att lämna erlangskalet är: init:stop() som gör samma sak som q() eller erlang:halt() .

Mönstermatchning

En av de vanligaste operationerna inom erlang är mönstermatchning. Det används vid tilldelning av ett värde till en variabel, i funktionsdeklarationer och i kontrollflödesstrukturer som case och receive . En mönstermatchningsoperation behöver minst två delar: ett mönster och en term mot vilken mönstret matchas.

En variabel tilldelning i erlang ser ut så här:

X = 2.

I de flesta programmeringsspråk är semantiken i den här operationen enkel: Bind ett värde ( 2 ) till ett namn du väljer (variabeln - i detta fall X ). Erlang har en något annorlunda inställning: Matcha mönstret på vänster sida ( X ) till termen på höger sida ( 2 ). I detta fall är effekten densamma: variabeln X är nu bunden till värdet 2 . Men med mönstermatchning kan du utföra mer strukturerade uppdrag.

{Type, Meta, Doc} = {document, {author, "Alice"}, {text, "Lorem Ipsum"}}.

Denna matchande operation utförs genom att analysera strukturen på höger sida term och använda alla variabler på vänster sida till lämpliga värden på termen, så att vänster sida är lika med höger sida. I det här exemplet är Type bunden till termen: document , Meta till {author, "Alice"} och Doc till {text, "Lorem Ipsum"} . I det här exemplet antas variablerna: Type , Meta och Doc vara obundna , så att varje variabel kan användas.

Mönstermatchningar kan också byggas med hjälp av bundna variabler.

Identifier = error.

Variabeln Identifier är nu bunden till värdet error . Följande mönstermatchningsoperation fungerar, eftersom strukturen matchar, och den bundna variabeln Identifier har samma värde som lämplig höger sida av termen.

{Identifier, Reason} = {error, "Database connection timed out."}.

En mönstermatchningsoperation misslyckas när det finns ett missförhållande mellan höger sida term och vänster sida mönster. Följande match kommer att misslyckas, eftersom Identifier är bunden till värdet error , som inte har något lämpligt uttryck på höger sida term.

{Identifier, Reason} = {fail, "Database connection timed out."}.
> ** exception error: no match of right hand side value {fail,"Database ..."}