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]}

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