Erlang 错误处理：try-catch 与 throw

Erlang 是一门以高并发、高可靠性著称的编程语言。在分布式系统和电信领域，程序需要长时间不间断运行，任何未被妥善处理的错误都可能导致整个系统崩溃。因此，理解并正确使用错误处理机制，是写出健壮 Erlang 程序的关键一步。

Erlang 提供了多种处理异常的方式，其中最核心的是 try-catch 表达式和 throw 函数。它们各自承担不同的职责：前者负责捕获并处理异常，后者负责主动抛出异常。掌握这两者的用法，能让你在面对错误时拥有完整的控制权。

1. 理解异常的本质

在 Erlang 中，异常本质上是一种"跳出当前执行流程"的机制。当程序遇到无法继续执行的情况时，可以通过抛出异常来立即终止当前的函数调用，并将控制权交给上层的错误处理逻辑。这种机制避免了传统的错误码检查方式——你不需要在每一个函数调用后都写一堆 if 语句来判断操作是否成功。

异常在 Erlang 中有三种主要类型：

运行时错误（error） 是最常见的异常类型，通常由程序中的 Bug 引发，比如除以零、模式匹配失败、调用不存在的函数等。当这类错误发生时，进程通常会终止。

退出信号（exit） 通常用于表示进程无法继续工作，可能是主动调用 exit/1 触发的，也可能是系统检测到严重问题后自动发出的。退出信号可以在进程之间传播。

抛出（throw） 是一种程序员主动使用的异常机制，专门用于非错误情况的控制流跳转。比如当你需要从一个深层嵌套的函数中返回时，使用 throw 可以避免逐层传递返回值。

2. 使用 throw 主动抛出异常

throw 函数用于主动抛出一个异常。这种机制常用于以下场景：当函数遇到无法处理的特殊情况，但又不想返回错误码时；或者需要从多层函数调用中快速跳出时。

掌握 throw 的基本语法：

throw(Reason)

throw 的参数 Reason 可以是任意 Erlang 数据结构，常见的是原子或元组。

创建辅助函数并在适当时机抛出异常：

find_user(Id, Users) ->
    case lists:keyfind(Id, 1, Users) of
        false -> throw({user_not_found, Id});
        User -> User
    end.

process_user(Id, Users) ->
    try find_user(Id, Users) of
        User -> {ok, User}
    catch
        throw:{user_not_found, MissingId} ->
            io:format("User ~p not found~n", [MissingId]),
            {error, not_found}
    end.

在这个示例中，find_user 函数在找不到指定用户时，没有简单地返回 false，而是调用 throw({user_not_found, Id}) 抛出一个异常。这个异常携带了具体的用户 ID 信息，便于上层代码进行针对性处理。process_user 使用 try-catch 捕获这个异常，并将其转换为更友好的错误返回。

3. 使用 try-catch 捕获异常

try-catch 是 Erlang 中处理异常的核心语法结构。它的作用是将可能抛出异常的代码包裹起来，并指定不同类型异常的处理方式。

掌握 try-catch 的完整语法：

try Expression of
    Pattern1 -> Body1;
    Pattern2 -> Body2
catch
    Type1:Pattern1 -> Handler1;
    Type2:Pattern2 -> Handler2
after
    CleanupCode
end

这个结构可以分解为四个部分：try 后面的表达式是要监控的代码；of 后面是正常执行路径的模式匹配，类似于 case；catch 后面定义各类异常的处理逻辑；after 后面的代码无论是否发生异常都会执行，通常用于资源清理。

理解各部分的实际作用：

dangerous_operation(X) ->
    try
        Result = calculate(X),
        {ok, Result}
    of
        Val -> {success, Val}
    catch
        error:badarith ->
            io:format("Arithmetic error occurred~n"),
            {error, arithmetic};
        error:{badmatch, _} ->
            io:format("Pattern match failed~n"),
            {error, match};
        throw:custom_reason ->
            io:format("Custom throw caught~n"),
            {error, custom}
    end.

注意 catch 子句中的 Type:Pattern 语法。Type 指定了异常的类型，可以是 error、exit 或 throw，或者是它们的组合。Pattern 则用于匹配异常的原因值。省略 Type 时，默认为 throw，这是为了兼容旧式写法，但不推荐在新代码中这样做。

4. 区分并正确捕获不同异常类型

不同类型的异常有其特定的使用场景和传播行为。理解这些差异，能帮助你在合适的场合选择合适的异常类型。

error 类型通常用于程序错误：

divide(_,_) when X == 0 ->
    error(division_by_zero);
divide(A, B) ->
    A / B.

exit 类型表示进程终止：

critical_failure() ->
    exit({critical, system_shutdown}).

throw 类型用于控制流：

find_in_list(Pred, [H|T]) ->
    case Pred(H) of
        true -> throw({found, H});
        false -> find_in_list(Pred, T)
    end;
find_in_list(_, []) ->
    false.

search(List) ->
    try find_in_list(fun(X) -> X > 100 end, List) of
        false -> not_found
    catch
        throw:{found, Value} -> {found, Value}
    end.

批量捕获多种异常类型：

handle_with_caution(Action) ->
    try Action of
        _ -> ok
    catch
        error:E when E =:= badarith ->
            {error, arithmetic};
        error:E when is_tuple(E), element(1, E) =:= badmatch ->
            {error, match};
        throw:E ->
            {error, {thrown, E}};
        exit:E ->
            {error, {exited, E}}
    end.

5. 使用 after 进行资源清理

after 子句确保资源一定被释放，无论代码是否发生异常。这对于文件句柄、网络连接、锁等资源的释放至关重要。

确保文件句柄被正确关闭：

process_file(Path) ->
    {ok, Device} = file:open(Path, [read]),
    try
        process_data(Device)
    after
        file:close(Device)
    end.

process_data(Device) ->
    case io:get_line(Device, "") of
        eof -> done;
        Line ->
            io:format("~s", [Line]),
            process_data(Device)
    end.

after 子句有几个重要特性需要注意：首先，它不返回值，整个 try 表达式的返回值由 of 或 catch 部分决定；其次，after 中抛出异常会导致原始异常丢失，所以应避免在其中执行可能失败的代码；最后，after 是可选的，只有在需要资源清理时才使用。

6. 实战：构建健壮的配置文件解析器

将上述概念组合起来，构建一个能够优雅处理各种错误的配置文件解析器：

-module(config_parser).
-export([load/1]).

-record(config, {host, port, timeout}).

load(FilePath) ->
    try
        {ok, Content} = file:read_file(FilePath),
        parse_config(Content)
    of
        Config -> {ok, Config}
    catch
        error:{badmatch, {error, enoent}} ->
            {error, file_not_found};
        error:{badmatch, {error, eacces}} ->
            {error, permission_denied};
        error:Reason ->
            {error, {parse_error, Reason}}
    end.

parse_config(Binary) ->
    try
        Lines = binary:split(Binary, <<"\n">>, [global]),
        Config = #config{},
        lists:foldl(fun(Line, Acc) ->
            parse_line(Line, Acc)
        end, Config, Lines)
    of
        #config{host=H, port=P} when is_integer(P), P > 0, P < 65536 ->
            #config{host=H, port=P, timeout=3000};
        _ ->
            throw(invalid_config)
    end.

parse_line(<<>>, Acc) -> Acc;
parse_line(<<"#", _/binary>>, Acc) -> Acc;
parse_line(<<"host=", Value/binary>>, Acc) ->
    Host = binary:trim(Value),
    Acc#config{host=Host};
parse_line(<<"port=", Value/binary>>, Acc) ->
    case binary:to_integer(Value) of
        {Port, <<>>} when Port > 0 ->
            Acc#config{port=Port};
        _ ->
            throw({invalid_port, Value})
    end;
parse_line(Line, Acc) when byte_size(Line) > 0 ->
    throw({unknown_directive, Line}).

%% 使用示例
%% {ok, Config} = config_parser:load("app.config").

这个解析器展示了多种错误处理策略：使用 try-catch 包裹文件操作，捕获文件不存在、权限问题等 IO 错误；在配置解析过程中使用 throw 处理非法端口值和未知指令；使用模式匹配在最后验证配置的有效性。这种分层处理让错误信息清晰且便于调试。

7. 常见错误与最佳实践

避免过度使用异常： 异常应该用于真正的异常情况，而不是作为普通的控制流手段。如果一个函数需要返回"未找到"结果，使用 {ok, Value} | not_found 这样明确的返回类型比抛出异常更合适。

提供有价值的错误信息： 抛出的异常应该携带足够的上下文信息。throw({error, reason}) 比 throw(error) 更利于调试。尽可能在异常中包含相关变量的值。

保持异常处理简洁： catch 子句中的处理代码应该尽量简单，避免在处理异常时抛出新的异常，这会导致原始错误信息丢失。

使用特定的错误类型： 区分 error、exit 和 throw 的使用场景。程序错误用 error，主动关闭用 exit，控制流跳转用 throw。

Erlang 的错误处理机制虽然与多数语言不同，但一旦掌握，就能写出高度可靠的程序。try-catch 提供了捕获和处理异常的完整框架，throw 则让你能够主动控制程序的执行流程。记住，良好的错误处理不是避免错误发生，而是让错误发生时系统能够优雅地降级或恢复。