Erlang Language Ciao mondo


Esempio

Ci sono due cose che devi sapere quando scrivi un'applicazione "ciao mondo" in Erlang:

  1. Il codice sorgente è scritto nel linguaggio di programmazione di erlang usando l'editor di testo di tua scelta
  2. L'applicazione viene quindi eseguita nella macchina virtuale di erlang . In questo esempio interagiremo con l'erlang VM attraverso la shell di erlang.

Prima il codice sorgente dell'applicazione:

Crea un nuovo file hello.erl contenente quanto segue:

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

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

Diamo una rapida occhiata a cosa significa:

  • -module(hello). Tutte le funzioni di erlang esistono all'interno di un modulo . I moduli vengono quindi utilizzati per creare applicazioni, che sono una raccolta di moduli. Questa prima linea è identificare questo modulo, cioè ciao . I moduli possono essere confrontati con i pacchetti di Java
  • -export([hello_world/0]). Indica al compilatore quali funzioni rendere "pubbliche" (rispetto alle lingue OO) e l' arità della funzione pertinente. L'arità è il numero di argomenti che la funzione assume. Dato che in erlang una funzione con 1 argomento è vista come una funzione diversa da una con 2 argomenti anche se il nome potrebbe essere esattamente lo stesso. Cioè, hello_world/0 è una funzione completamente diversa da hello_world/1 per esempio.
  • hello_world() Questo è il nome della funzione. -> indica la transizione all'attuazione (corpo) della funzione. Questo può essere letto come "hello_world () è definito come ...". Prendi nota che hello_world() (nessun argomento) è identificato da hello_world/0 nella VM e hello_world(Some_Arg) come hello_world/1 .
  • io:format("Hello, World!~n", []) Dal modulo io , viene chiamata la funzione format/2 function, che è la funzione per l'output standard. ~n è un identificatore di formato che significa stampare una nuova riga. [] È un elenco di variabili da stampare indicato dagli specificatori di formato nella stringa di output, che in questo caso non è nulla.
  • Tutte le dichiarazioni di erlang devono terminare con a . (punto).

In Erlang, viene restituito il risultato dell'ultima istruzione in una funzione.

Ora, eseguiamo la nostra applicazione:

Avvia la shell di erlang dalla stessa directory del file hello.erl file:

$ erl

Dovresti ricevere una richiesta simile a questa (la tua versione potrebbe essere diversa):

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

Ora inserisci i seguenti comandi:

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

Passiamo attraverso ciascuna riga una ad una:

  • c(hello) - questo comando chiama la funzione c su un atomo hello . Questo in effetti dice a Erlang di trovare il file hello.erl , compilarlo in un modulo (un file denominato hello.beam verrà generato nella directory) e caricarlo nell'ambiente.
  • {ok, hello} - questo è il risultato di chiamare la funzione c sopra. È una tupla contenente un atom ok e un atomo hello . Le funzioni di Erlang solitamente restituiscono {ok, Something} o {error, Reason} .
  • hello:hello_world() - questo chiama una funzione hello_world() dal modulo hello .
  • Hello, World! - questo è ciò che la nostra funzione stampa.
  • ok - questo è ciò che la nostra funzione ha restituito. Dal momento che Erlang è un linguaggio di programmazione funzionale, ogni funzione restituisce qualcosa . Nel nostro caso, anche se non abbiamo restituito nulla in hello_world() , l'ultima chiamata in quella funzione era in io:format(...) e quella funzione ha restituito ok , che è a sua volta ciò che la nostra funzione ha restituito.