catch和throw提供了一种表达式求值的监视机制，可以用于- 处理顺序代码中的错误（catch）- 函数的非本地返回（catch结合throw）表达式求值失败（如一次匹配失败）的一般后果是导致求值进程的异常退出。通过以下方式可以借助catch来更改这个默认行为：若表达式的求值过程没有发生错误，则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) foo(2)
    执行throw({myerror,abc})。由于不在catch的作用域内，执行foo(2)的进程将出错退出。
    foo(3)
    执行foo(3)的进程执行BIF tuple_to_list(a)。这个BIF用于将元组转换为列表。在这个例子中，参数不是元组，因此该进程将出错退出。
    foo(4) foo(5)
    执行foo(5)的进程将出错退出，因为函数foo/1的首部无法匹配foo(5)。
    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) demo(3)
    求值结果为{caught_error,badarg}。foo(3)执行失败导致catch返回{'EXIT',badarg}。
    demo(4)
    求值结果为{caught_error,{myexit,222}}。
    demo(5)

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

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

    正确情况下，应该匹配到第一个子句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. parse_list(['[', X | T]) when integer(X) ->
    3.     {Tail, T1} = parse_list_tail(T),
    4.     {{cons, X, Tail}, T1}.
    5.  
    6. parse_list_tail([',', X | T]) when integer(X) ->
    7.     {Tail, T1} = parse_list_tail(T),
    8.     {{cons, X, Tail}, T1};
    9. parse_list_tail([']' | T]) ->
    10.     {nil, T}.
    1. > parse_list(['[',12,',',20,']']).
    2. {{cons,12,{cons,20,nil}},[]}

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

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

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

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