第10章 错误处理与联合类型

第10章 错误处理与联合类型

在 Zig 中，错误处理是语言的核心组成部分，而非事后添加的功能。与许多语言中“异常”的概念不同，Zig 将错误视为值 (Value)。这意味着错误不能被忽略，必须显式地处理。

本章将深入探讨 Zig 的错误处理哲学，包括：

  1. 错误值 (Error Value) 和 错误集 (Error Set)。
  2. 处理错误的各种策略：try、catch、if 和 errdefer。
  3. 联合类型 (Union Type) 及其在错误处理中的应用。

1. 错误的本质：值 (Error as Value)

在 Zig 中，错误不是“异常”，而是一种特殊的值。这意味着：

  • 错误值可以被返回、传递、存储。
  • 错误值必须被显式处理，不能像普通返回值那样被默默丢弃。

如果你尝试丢弃一个错误值，编译器会报错：

const std = @import("std");

pub fn main() !void {
    const dir = std.fs.cwd();
    // 编译器会报错：error set is discarded
    _ = dir.openFile("doesnt_exist.txt", .{}); 
}

返回错误

一个函数如果可能返回错误，其返回类型前必须加上感叹号 !。

!T 表示函数可能返回类型 T 的值，也可能返回一个错误。

fn doSomething() !void {
    // ... 可能返回错误的代码
    try std.io.getStdOut().writer().print("Hello", .{});
}

你可以更具体地指定可能返回哪些错误，方法是在 ! 前列出错误类型：

SomeError!void 表示函数要么成功返回 void，要么返回 SomeError。

错误集 (Error Sets)

当一个函数可能返回多种不同类型的错误时，我们可以用错误集来集合这些错误。错误集通过 error{ ... } 语法定义，它本身也是一种类型。

例如，Zig 标准库中的 std.fs.File.openFile 函数的返回类型可能是这样的：

pub fn openFile(path: []const u8, options: OpenOptions) !File {
    // ...
}
// 这里的 !File 实际上是一个隐含的错误集，通常是：
// error{ FileSystemError, AccessDenied, PathTooLong, OutOfMemory, ... }!File

你可以定义自己的错误集：

pub const NetworkError = error{
    ConnectionTimeout,
    HostNotFound,
    AccessDenied,
};

fn sendRequest() NetworkError!void {
    // ...
    return NetworkError.ConnectionTimeout; // 返回错误集的具体错误
}

错误集允许我们将相关的错误类型进行分组。如果一个错误集 A 包含了另一个错误集 B 的所有错误，那么 A 就是 B 的超集。Zig 允许在超集和子集之间进行错误的隐式转换。

2. 错误处理策略

Zig 提供了多种策略来处理错误，每种都有其适用场景。

策略一：try 关键字 (快速失败 / Propagate Error)

try 是最常用的错误处理方式。它告诉编译器：“尝试执行此操作，如果成功，就使用结果；如果失败，立即将错误从当前函数返回。”

fn readConfig() ![]u8 {
    // try 会尝试打开文件。如果失败，readConfig 函数会立即返回 FileSystemError
    const file = try std.fs.cwd().openFile("config.txt", .{});
    defer file.close(); // defer 确保在函数退出时关闭文件

    var buffer: [1024]u8 = undefined;
    const bytes_read = try file.read(&buffer); // 如果读取失败，也立即返回错误
    
    return buffer[0..bytes_read];
}

try 的作用类似于其他语言中的“抛出异常”或“短路求值”，它简化了错误传播。

策略二：catch 关键字 (处理错误 / Handle Error)

catch 允许你在当前位置处理错误，而不是传播它。它通常与一个表达式结合使用。

语法：expression catch |err| { ... } 或 expression catch fallback_value

fn parseNumber(s: []const u8) !u64 {
    return std.fmt.parseUnsigned(u64, s, 10);
}

pub fn main() !void {
    // 方式一：提供一个默认值
    const value = parseNumber("123") catch 0; // 如果解析失败，value 为 0

    // 方式二：执行一段错误处理逻辑
    const another_value = parseNumber("abc") catch |err| {
        std.debug.print("Failed to parse: {}\n", .{err});
        return 0; // 或者返回一个错误，或者 panic
    };
}

策略三：if 语句 (结构化处理)

if 语句可以用来解包错误，并根据不同的情况进行处理。这在需要对不同错误类型做不同响应时非常有用。

if (parseNumber("456")) |num| {
    // 解析成功，num 是 u64 类型
    std.debug.print("Parsed: {d}\n", .{num});
} else |err| {
    // 解析失败，err 是错误类型
    std.debug.print("Parse error: {}\n", .{err});
    if (err == error.Overflow) {
        std.debug.print("Number too large!\n", .{});
    }
}

如果你有多种错误类型需要分别处理，而 catch 的逻辑块变得复杂，那么结合 if 和 switch 来处理错误会更加清晰：

if (attemptOperation()) |result| {
    // 操作成功
} else |err| switch (err) {
    error.PermissionDenied => { /* 处理权限错误 */ },
    error.NetworkIssue => { /* 处理网络错误 */ },
    else => { /* 处理其他所有错误 */ },
}

策略四：errdefer 关键字 (错误时清理)

errdefer 关键字确保只有在当前作用域因错误退出时，注册的代码才会被执行。

这对于资源清理至关重要，特别是当资源在一个函数中分配，但其生命周期可能延续到调用者时。

fn createFileAndWrite(allocator: Allocator) !void {
    const file_name = "output.txt";
    const file = try std.fs.cwd().createFile(file_name, .{});
    // errdefer 确保：如果文件创建成功但后续写入失败，文件会被删除
    errdefer std.fs.cwd().deleteFile(file_name) catch {}; // 删除文件，忽略删除错误

    // defer 确保：无论成功失败，文件句柄都会被关闭
    defer file.close(); 

    // ... 写入操作，可能失败
    try file.writeAll("Some content");
}
  • defer vs errdefer：
    • defer：无条件执行，无论作用域是成功还是失败退出。适合关闭文件句柄、释放锁等。
    • errdefer：条件性执行，只有当作用域因错误退出时才执行。适合回滚操作、清理部分完成的工作。

3. 联合类型 (Union Types)

联合类型允许一个变量在不同时间持有不同类型的值。这在需要表示“可能是 A 也可能是 B”的数据结构时非常有用。

定义联合类型

const Shape = union {
    circle: Circle,
    square: Square,
    triangle: Triangle,
};

const Circle = struct { radius: f32 };
const Square = struct { side: f32 };
const Triangle = struct { base: f32, height: f32 };

pub fn main() void {
    var my_shape: Shape = .{ .circle = .{ .radius = 10.0 } };
    
    // my_shape 现在是 Circle 类型
    // std.debug.print("Radius: {d}\n", .{my_shape.circle.radius});

    // 改变联合的活动成员
    my_shape = .{ .square = .{ .side = 5.0 } };
    // std.debug.print("Side: {d}\n", .{my_shape.square.side});
    
    // my_shape.circle.radius; // 错误！circle 不再是活动成员
}

访问联合成员

联合类型在任何时候只能有一个活动成员 (Active Member)。当你尝试访问非活动成员时，Zig 会阻止你（Debug 模式下会 panic）。

通常，我们会结合 switch 语句来安全地处理联合类型：

fn getArea(shape: Shape) f32 {
    return switch (shape) {
        .circle => |c| std.math.pi * c.radius * c.radius,
        .square => |s| s.side * s.side,
        .triangle => |t| 0.5 * t.base * t.height,
    };
}

标记联合 (Tagged Unions)

默认情况下，Zig 的联合类型是非标记联合 (Untagged Unions)，这意味着编译器无法知道当前哪个成员是活动的。所以你不能直接在 switch 语句中使用。

为了让编译器知道当前联合变量存储的是哪个类型，我们需要创建标记联合 (Tagged Unions)。

通过在 union 关键字后添加一个枚举类型，即可创建标记联合：

pub const Registry = union(enum) { // (enum) 使得它成为标记联合
    core: CoreRegistry,
    extension: ExtensionRegistry,
};

// 现在就可以在 switch 语句中安全地使用 Registry 类型的变量了
fn processRegistry(reg: Registry) void {
    switch (reg) {
        .core => |c| { /* 处理 CoreRegistry */ },
        .extension => |e| { /* 处理 ExtensionRegistry */ },
    }
}

总结

Zig 的错误处理和联合类型是其安全性和表达力的重要组成部分：

  1. 错误即值：强制显式处理所有错误。
  2. try 传播，catch 处理：清晰的错误流控制。
  3. errdefer 清理：确保资源在错误发生时也能被妥善管理。
  4. 联合类型：优雅地处理多类型数据，标记联合确保类型安全。

掌握这些，你就能编写出更健壮、更可靠的 Zig 代码。

原文出处: https://pedropark99.github.io/zig-book/

Previous 第9章 构建系统 (Build System) Next 第11章 常用数据结构