• Catch和Throw
    • 使用catch和throw抵御不良代码
    • 使用catch和throw实现函数的非本地返回

    Catch和Throw

    catch和throw提供了一种表达式求值的监视机制，可以用于- 处理顺序代码中的错误（catch）- 函数的非本地返回（catch结合throw）表达式求值失败（如一次匹配失败）的一般后果是导致求值进程的异常退出。通过以下方式可以借助catch来更改这个默认行为：
    1. catch Expression
    若表达式的求值过程没有发生错误，则catchExpression返回Expression的值。于是catchatom_to_list(abc)会返回[97,98,99]、catch22会返回22。若求值过程失败，catchExpression将返回元组{'EXIT',Reason}，其中Reason是用于指明错误原因的原子式（参见第??节）。于是catchan_atom-2会返回{'EXIT',badarith}、catchatom_to_list(123)会返回{'EXIT',badarg}。函数执行结束后，控制流程便返还者。throw/1可以令控制流程跳过调用者。如果我们像上述的那样计算catchExpression，并在Expression的求值过程中调用throw/1，则控制流程将直接返回至catch。注意catch可以嵌套；在嵌套的情况下，一次失败或throw将返回至最近的catch处。在catch之外调用throw/1将导致运行时错误。下面的例子描述了catch和throw的行为。定义函数foo/1：
    1. foo(1) ->    hello;foo(2) ->    throw({myerror, abc});foo(3) ->    tuple_to_list(a);foo(4) ->    exit({myExit, 222}).
    假设在不使用catch的情况下，一个进程标识为Pid的进程执行了这个函数，则：foo(1)
    返回hello。
    foo(2)
    执行throw({myerror,abc})。由于不在catch的作用域内，执行foo(2)的进程将出错退出。
    foo(3)
    执行foo(3)的进程执行BIF tuple_to_list(a)。这个BIF用于将元组转换为列表。在这个例子中，参数不是元组，因此该进程将出错退出。
    foo(4)
    执行BIF exit/1。由于不在catch的范围内，执行foo(4)的函数将退出。很快我们就会看到参数{myExit,222}的用途。
    foo(5)
    执行foo(5)的进程将出错退出，因为函数foo/1的首部无法匹配foo(5)。

    现在让我们来看看在catch的作用域内对foo/1以相同的参数进行求值会发生什么：

    1. demo(X) ->
    2.     case catch foo(X) of
    3.         {myerror, Args} ->
    4.             {user_error, Args};
    5.         {'EXIT', What} ->
    6.             {caught_error, What};
    7.         Other ->
    8.             Other
    9.     end.
    demo(1)
    像原来一样执行hello。因为没有任何失败发生，而我们也没有执行throw，所以catch直接返回foo(1)的求值结果。
    demo(2)
    求值结果为{user_error,abc}。对throw({myerror,abc})的求值导致外围的catch返回{myerror, abc}同时case语句返回{user_error,abc}。
    demo(3)
    求值结果为{caught_error,badarg}。foo(3)执行失败导致catch返回{'EXIT',badarg}。
    demo(4)
    求值结果为{caught_error,{myexit,222}}。
    demo(5)
    求值结果为{caught_error,function_clause}。

    注意，在catch的作用域内，借助{'EXIT',Message}，你能够很容易地“伪造”一次失败——这是一个设计决策[1]。

    使用catch和throw抵御不良代码

    下面来看一个简单的Erlang shell脚本：

    1. -module(s_shell).
    2. -export([go/0]).
    3.  
    4. go() ->
    5.     eval(io:parse_exprs('=> ')),    % '=>' is the prompt
    6.     go().
    7.  
    8. eval({form,Exprs}) ->
    9.     case catch eval:exprs(Exprs, []) of % Note the catch
    10.         {'EXIT', What} ->
    11.             io:format("Error: ~w!~n", [What]);
    12.         {value, What, _} ->
    13.             io:format("Result: ~w~n", [What])
    14.     end;
    15. eval(_) ->
    16.     io:format("Syntax Error!~n", []).

    标准库函数io:parse_exprs/1读取并解析一个Erlang表达式，若表达式合法，则返回{form,Exprs}。

    正确情况下，应该匹配到第一个子句eval({form,Expr})并调用库函数eval:exprs/2对表达式进行求值。由于无法得知表达式的求值过程是否为失败，我们在此使用catch进行保护。例如，对1-a进行求值将导致错误，但在catch内对1-a求值就可以捕捉这个错误[2]。借助catch，在求值失败时，case子句与模式{'EXIT',what}匹配，在求值成功时则会与{value,What,_}匹配。

    使用catch和throw实现函数的非本地返回

    假设我们要编写一个用于识别简单整数列表的解析器，可以编写如下的代码：

    1. parse_list(['[',']' | T])
    2.     {nil, T};
    3. parse_list(['[', X | T]) when integer(X) ->
    4.     {Tail, T1} = parse_list_tail(T),
    5.     {{cons, X, Tail}, T1}.
    6.  
    7. parse_list_tail([',', X | T]) when integer(X) ->
    8.     {Tail, T1} = parse_list_tail(T),
    9.     {{cons, X, Tail}, T1};
    10. parse_list_tail([']' | T]) ->
    11.     {nil, T}.

    例如：

    1. > parse_list(['[',12,',',20,']']).
    2. {{cons,12,{cons,20,nil}},[]}

    要是我们试图解析一个非法的列表，就会导致如下的错误：

    1. > try:parse_list(['[',12,',',a]).
    2. !!! Error in process <0.16.1> in function
    3. !!!     try:parse_list_tail([',',a])
    4. !!! reason function_clause
    5. ** exited: function_clause **

    如果我们想在跳出递归调用的同时仍然掌握是哪里发生了错误，可以这样做：

    1. parse_list1(['[',']' | T]) ->
    2.     {nil, T};
    3. parse_list1(['[', X | T]) when integer(X) ->
    4.     {Tail, T1} = parse_list_tail1(T),
    5.     {{cons, X, Tail}, T1};
    6. parse_list1(X) ->
    7.     throw({illegal_token, X}).
    8.  
    9. parse_list_tail1([',', X | T]) when integer(X) ->
    10.     {Tail, T1} = parse_list_tail1(T),
    11.     {{cons, X, Tail}, T1};
    12. parse_list_tail1([']' | T]) ->
    13.     {nil, T};
    14. parse_list_tail1(X) ->
    15.     throw({illegal_list_tail, X}).

    现在，如果我们在catch里对parse_list/1求值，将获得以下结果：

    1. > catch parse_list1(['[',12,',',a]).
    2. {illegal_list_tail,[',',a]}

    通过这种方式，我们得以从递归中直接退出，而不必沿着通常的递归调用路径逐步折回。