Exceções do Erlang

Em qualquer linguagem de programação, é necessário lidar com exceções para lidar com erros de tempo de execução, para manter o fluxo normal do aplicativo. As exceções geralmente interrompem o fluxo normal do aplicativo, isso é por que precisamos usar tratamento de exceções no aplicativo.

Normalmente, quando ocorre uma exceção ou erro no Erlang, a seguinte mensagem é exibida.

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

O dump de falha será escrito-

erl_crash.dump
init　terminating　in　do_boot　()

No Erlang, há3essas exceções tipo-

• Error−a chamada terminará a execução do processo atual, e incluirá o rastreamento da pilha ao capturar a última função e seus parâmetros. Essas são as exceções de erro de tempo de execução mencionadas acima.erlang:error(Razão)

• Exit −existem dois tipos de exit : saida interna e saida externa. A saida interna é feita por meio da chamada da função exit/1para desencadear e fazer com que o processo atual pare de executar. A saída externa está em exit/2é chamado e está relacionado a múltiplos processos na concurrency do Erlang.

• Throw −throw é uma classe de exceções usada para situações que os programadores podem lidar. Em comparação com o desligamento e os erros, elas não trazem nenhum processo de 'desastre!' Eles têm a intenção de controlar o fluxo. Quando você usa throws para esperar que o programador lidere, é melhor registrar seu uso no módulo onde eles são usados.

try...catch é um método de cálculo de expressão que permite que você lidar com casos de sucesso e erros encontrados.

tentar-A sintaxe geral da expressão catch é como follows.

sintaxe

tentar Expressão de　
PadrãoSucesso1　[Guardas]　->　
Expressão1;　
PadrãoSucesso2　[Guardas]　->　
Expressão2　
catch TypeOfError:PadrãoDeExceção1　->　
Expressão3;　
TypeOfError:PadrãoDeExceção2　->　
Expressão4　
end

A expressão entre try e of é chamada de protegida. Isso significa que qualquer tipo de exceção que ocorrer na chamada será capturada. O padrão e a expressão entre try... e catch são exatamente os mesmos que no case...

Finalmente, a parte catch - aqui, você pode substituir TypeOfError por error, throw ou exit para cada tipo que viu neste capítulo. Se não for fornecido um tipo, assume-se que é lançado.

A seguir, um exemplo de como usar essas exceções e como lidar com elas.

• A primeira função gera todos os tipos possíveis de exceções.

• Então, escrevemos uma função de encapsulamento que chama generate_exception dentro de uma expressão try…catch.

Exemplo Online

-module(helloworld).　
-compile(export_all).　
generate_exception(1)　->　a;　
generate_exception(2)　->　throw(a);　
generate_exception(3)　->　exit(a);　
generate_exception(4)　-> {'SAÍDA', a};　
generate_exception(5)　->　erlang:error(a).　
demo1())　->　
　　　[catcher(I) || I <-　[1,2,3,4,5)].　
catcher(N)　->　
　　　tentar gerar_exception(N)　
　　　　　　Val　->　{N,　normal,　Val}　
　　　catch　
　　　　　　lançar:X　-> {N, capturada, lançada, X};　
　　　　　　saída:X　-> {N, capturada, encerrada, X};　
　　　　　　erro:X　-> {N, capturada, erro, X}　
　　　fim.　
　　　　　　
demo2())　->　
　　　[{I, (catch gerar_exceção(I))} || I <-　[1,2,3,4,5)].　
demo3())　->　
　　　tentar gerar_exceção(5)　
　　　catch　
　　　　　　erro:X　->　
　　　　　　　　　{X, erlang:get_stacktrace()}　
　　　fim.　
　　　
procurar(N)　->　
　　　case(N) of　
　　　　　　1　-> {'SAÍDA', a};　
　　　　　　2　-> saída(a)　
　　　fim.

Se executarmos a função HelloWorld:demo()., obteremos a seguinte saída

[{1,normal,a},
{2,capturada,lançada,a},
{3,capturada,encerrada,a},
{4,normal,{'SAÍDA',a}},
{5,capturada,erro,a}]