异常 Erlang

In qualsiasi linguaggio di programmazione, è necessario gestire le eccezioni per gestire gli errori di runtime, in modo da mantenere il flusso normale dell'applicazione. Le eccezioni di solito interrompono il flusso normale dell'applicazione, ecco perché dobbiamo utilizzare la gestione delle eccezioni nell'applicazione.

Di solito, quando si verificano eccezioni o errori in Erlang, viene visualizzato il seguente messaggio.

{"init terminando in do_boot",　{undef,[{helloworld,start,[],[]},　
{init,start_it,1,[]},{init,start_em,1,[]}]}}

Il dump di故障sarà scritto-

erl_crash.dump
init terminando in do_boot ()

In Erlang ci sono 3 tipi di eccezioni-

Error−la chiamata terminerà l'esecuzione del processo corrente e includerà il tracciamento della pila quando viene catturato l'ultimo funzione e i suoi parametri. Queste sono le eccezioni che causano gli errori di runtime menzionati sopra.erlang:error(Reason)
Exists −ci sono due tipi di Exists: uscita interna e uscita esterna. L'uscita interna viene attivata chiamando la funzione exit/1 e ferma l'esecuzione del processo corrente. L'uscita esterna viene chiamata con exit/2 e ha a che fare con la condivisione dei processi di Erlang.
Throw −throw è una classe di eccezioni utilizzate per situazioni che possono essere gestite dai programmatori. A differenza dell'uscita e degli errori, non portano a nessun processo di 'crash!' dietro di loro, ma controllano il flusso. Quando si utilizza throw per aspettarsi che il programmatore gestisca il lancio, è meglio registrare l'uso nei moduli in cui vengono utilizzati.

try... catch è un metodo di calcolo dell'espressione che ti permette di gestire sia i casi di successo che gli errori che si incontrano.

La grammatica generale dell'espressione try-catch è come segue.

Grammatica

try　Expression　of　
SuccessfulPattern1　[Guards]　->　
Expression1;　
SuccessfulPattern2　[Guards]　->　
Expression2　
catch　TypeOfError:ExceptionPattern1　->　
Expression3;　
TypeOfError:ExceptionPattern2　->　
Expression4　
end

L'espressione tra try e of è detta protetta. Questo significa che qualsiasi tipo di eccezione che si verifica durante la chiamata viene catturata. Il modello e l'espressione tra try... e catch sono identici nel loro comportamento rispetto a case...

Infine, la parte catch - qui, puoi sostituire TypeOfError con error, throw o exit per ogni tipo visto in questo capitolo. Se non viene fornito un tipo, si assume che venga lanciato.

Error	Tipo di errore
badarg	Il tipo di dati del parametro è errato o il formato non è corretto.
badarith	Parametro errato nell'espressione aritmetica.
{badmatch,V}	Il calcolo dell'espressione dell'operatore match fallisce. Il valore V non corrisponde.
function_clause	Quando si valuta una chiamata di funzione, non si trova la clausola di funzione corrispondente.
{case_clause,V}	Quando si calcola un'espressione case, non si trova la branca corrispondente. Il valore V non corrisponde.
if_clause	Quando si valuta un'espressione if, non si trova la branca reale.
{try_clause,V}	Quando si calcola il segmento dell'espressione try, non si trova la branca corrispondente. Il valore V non corrisponde.
undef	Quando si valuta una chiamata di funzione, non si trova la funzione.
{badfun,F}	Il divertimento F ha avuto qualche problema
{badarit,F}	Un divertimento viene applicato al numero di argomenti di errore. F descrive il divertimento e le discussioni.
timeout_value	Il valore di timeout nell'espressione receive..after viene calcolato come qualsiasi valore diverso da intero o infinito.
noproc	Prova a collegarti a un processo non esistente.

Ecco un esempio di come utilizzare queste eccezioni e come gestirle.

La prima funzione genera tutti i tipi di eccezioni possibili.
Poi scriviamo una funzione wrapper, che chiama generate_exception all'interno dell'espressione try…catch.

Esempio online

-module(helloworld).　
-compile(export_all).　
generate_exception(1) -> a;　
generate_exception(2) -> throw(a);　
generate_exception(3) -> exit(a);　
generate_exception(4) -> {'EXIT', a};　
generate_exception(5) -> erlang:error(a).　
demo1() ->　
　　　[catcher(I) || I <- [1,2,3,4,5]].　
catcher(N) ->　
　　　try generate_exception(N) of　
　　　　　　Val -> {N, normal, Val}　
　　　catch　
　　　　　　throw:X -> {N, caught, thrown, X};　
　　　　　　exit:X -> {N, caught, exited, X};　
　　　　　　error:X -> {N, caught, error, X}　
　　　fine.　
　　　　　　
demo2() ->　
　　　[{I, (catch generate_exception(I))} || I <- [1,2,3,4,5]].　
demo3() ->　
　　　try generate_exception(5)　
　　　catch　
　　　　　　error:X ->　
　　　　　　　　　{X, erlang:get_stacktrace()}　
　　　fine.　
　　　
lookup(N) ->　
　　　case(N) of　
　　　　　　1 -> {'EXIT', a};　
　　　　　　2 -> exit(a)　
　　　fine.

Se eseguiamo il programma HelloWorld：:demo()., otterremo il seguente output

[{1,normal,a},
{2,caught,thrown,a},
{3,caught,exited,a},
{4,normal,{'EXIT',a}},
{5,caught,error,a}]

宏 Erlang 记录 Erlang

Erlang 教程

异常 Erlang

Grammatica

Esempio online