Zig 编程语言完全指南：现代系统编程的新选择

前言：为什么选择 Zig？

在系统编程领域，C 语言长期占据主导地位，但它的年龄带来了诸多安全问题和设计缺陷。Rust 试图通过所有权模型解决这些问题，但学习曲线极其陡峭。Zig 出现了——它承诺成为"更好的 C"，同时保持简洁性和高性能。

本指南将带你深入了解 Zig 语言的核心概念、特性和最佳实践。

第一部分：语言概述与设计哲学

1.1 什么是 Zig？

Zig 是一个通用的系统编程语言和工具链，由 Andrew Kelley 于 2016 年创建。它旨在成为C 语言的现代替代品，同时解决许多历史遗留问题。

核心特点：

手动内存管理但通过语言特性确保安全性
单一工具链：一个命令处理编译、测试、交叉编译
无隐藏控制流：没有异常、没有隐式内存分配
优秀的 C 互操作：无需 FFI，直接包含 C 头文件
内置测试：测试代码与实现代码在同一文件
编译时执行：将运行时计算移到编译期

1.2 设计哲学

"Better C" 理念

Zig 的设计目标不是重新发明系统编程，而是改进 C 的所有不足：

// C 风格的错误处理
int result = open_file("data.txt");
if (result == -1) {
    // 处理错误
}

// Zig 风格 - Error Unions
const file = try std.fs.cwd().openFile("data.txt", .{});
// try 关键字自动传播错误

核心原则

显式优于隐式：所有操作都应该是可见的
编译时计算优先：在编译期做尽可能多的工作
小而精的工具链：避免复杂的依赖关系
交叉编译优先：支持所有平台，无需额外配置

1.3 与其他语言对比

特性	Zig	C	C++	Rust
学习曲线	中等	低	高	很高
内存管理	手动 + 安全检查	手动	手动/RAII	所有权系统
错误处理	Error Unions	返回码	异常	Result{'<'}T,E{'>'}
泛型	comptime + anytype	宏	模板	Traits
编译速度	快	快	慢	中等
运行时	无	无	无	无
性能	接近 C	最高	高	高

性能对比（2025 数据）：

C: 1.23x（基准）
Zig: 1.18x
Rust: 1.12x

Zig 的性能接近 C，同时提供更好的安全性和开发体验。

1.4 Zig 的应用场景

✅ 适合的领域：

操作系统和内核开发
嵌入式系统
游戏引擎
高性能网络服务
编译器和工具链
WebAssembly 应用

❌ 不适合的领域：

快速原型开发（脚本语言更合适）
需要垃圾回收的应用
高级 Web 应用（TypeScript 更合适）

第二部分：快速开始

2.1 安装 Zig

从官网下载：

访问 ziglang.org/download 下载对应平台的版本。

使用包管理器：

# macOS
brew install zig

# Arch Linux
pacman -S zig

# Windows (Scoop)
scoop install zig

验证安装：

zig version
# 输出：0.15.2

2.2 Hello World

创建文件 hello.zig：

const std = @import("std");

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    try stdout.print("Hello, World!\n", .{});
}

运行：

zig run hello.zig
# 输出：Hello, World!

代码解析：

const std = @import("std") - 导入标准库
pub fn main() !void - 公共入口函数，返回可能的错误
!void - Error Union 类型，可能返回错误
try - 如果发生错误，立即返回
.{} - 空的匿名结构体（print 的参数列表）

2.3 基础语法

变量声明

const std = @import("std");

// const - 编译时常量（不可变）
const PI: f32 = 3.14159;

// var - 可变变量
var count: u32 = 0;

// 类型推断
const inferred = 42;        // comptime_int
var inferred_var = 3.14;    // f64

// @as() 用于显式类型转换
const value: i32 = @as(i32, 42);

pub fn main() void {
    var x: i32 = 10;
    x = 20;  // ✅ 可以修改 var

    const y: i32 = 30;
    // y = 40;  // ❌ 编译错误：不能修改 const
}

基本数据类型

// 整数类型
const unsigned: u32 = 42;     // 无符号 32 位整数
const signed: i32 = -10;      // 有符号 32 位整数
const pointer_size: usize = 64; // 指针大小的整数

// 浮点数
const float: f32 = 3.14;
const double: f64 = 2.71828;

// 布尔值
const is_valid: bool = true;
const is_empty: bool = false;

// 字符串（字节数组切片）
const greeting: []const u8 = "Hello, Zig!";
const multiline =
    \\Multi-line
    \\string
    \\literal

// Unicode 支持
const unicode: []const u8 = "你好世界";

数组

// 固定大小数组
const numbers: [5]u32 = .{1, 2, 3, 4, 5};
const zeros = [_]u32{0} ** 10;  // 10 个零

// 数组长度
const len = numbers.len;  // 5

// 访问元素
const first = numbers[0];  // 1
const last = numbers[4];   // 5

// 遍历数组
for (numbers, 0..) |num, index| {
    std.debug.print("Index {}: {}\n", .{index, num});
}

// 切片（数组的视图）
const slice: []const u32 = numbers[0..3];  // {1, 2, 3}

第三部分：核心语言特性

3.1 结构体（Structs）

基础结构体：

const Point = struct {
    x: f32,
    y: f32,

    // 方法
    fn distance(self: Point, other: Point) f32 {
        const dx = self.x - other.x;
        const dy = self.y - other.y;
        return @sqrt(dx * dx + dy * dy);
    }
};

pub fn main() void {
    const p1 = Point{ .x = 0.0, .y = 0.0 };
    const p2 = Point{ .x = 3.0, .y = 4.0 };
    const dist = p1.distance(p2);  // 5.0

    std.debug.print("Distance: {}\n", .{dist});
}

匿名结构体：

// 元组 - 使用字段序号访问
const tuple = .{ 1, "hello", true };
const first = tuple[0];   // 1
const second = tuple[1];  // "hello"

// 配置对象
const config = .{
    .host = "localhost",
    .port = 8080,
    .debug = true,
};

3.2 枚举（Enums）

const Color = enum(u8) {
    red,
    green,
    blue,

    // 方法
    fn toRgb(self: Color) [3]u8 {
        return switch (self) {
            Color.red => .{255, 0, 0},
            Color.green => .{0, 255, 0},
            Color.blue => .{0, 0, 255},
        };
    }
};

pub fn main() void {
    const favorite: Color = Color.blue;
    const rgb = favorite.toRgb();  // .{0, 0, 255}

    std.debug.print("RGB: {any}\n", .{rgb});
}

枚举字面量：

fn printColor(color: Color) void {
    _ = color;
}

// Zig 可以推断枚举类型
printColor(.red);  // 自动推断为 Color.red

3.3 联合（Unions）

const Value = union(enum) {
    integer: i64,
    float: f64,
    boolean: bool,

    fn print(self: Value) void {
        switch (self) {
            Value.integer => |i| std.debug.print("Integer: {}\n", .{i}),
            Value.float => |f| std.debug.print("Float: {}\n", .{f}),
            Value.boolean => |b| std.debug.print("Boolean: {}\n", .{b}),
        }
    }
};

pub fn main() void {
    const val1 = Value{ .integer = 42 };
    const val2 = Value{ .float = 3.14 };

    val1.print();  // Integer: 42
    val2.print();  // Float: 3.14
}

3.4 函数详解

基础函数：

// 简单函数
fn add(a: i32, b: i32) i32 {
    return a + b;
}

// 不返回值的函数
fn greet(name: []const u8) void {
    std.debug.print("Hello, {s}!\n", .{name});
}

// 表达式形式（更简洁）
fn mul(a: i32, b: i32) i32 {
    a * b;
}

Error Union 返回类型：

const ParseError = error{
    InvalidArgument,
    Overflow,
};

fn parseInt(str: []const u8) ParseError!i32 {
    const value = std.fmt.parseInt(i32, str, 10) catch {
        return ParseError.InvalidArgument;
    };
    return value;
}

pub fn main() !void {
    // 使用 try - 如果出错立即返回
    const value = try parseInt("123");
    std.debug.print("Parsed: {}\n", .{value});

    // 使用 catch - 捕获错误
    const result = parseInt("abc") catch |err| {
        std.debug.print("Error: {}\n", .{err});
        return 0;
    };
}

3.5 Optionals（可选类型）

Optionals 表示值可能存在或不存在：

fn findUser(id: u32) ?User {
    if (id == 0) return null;
    return User{ .id = id };
}

// orelse - 提供默认值
const user = findUser(1) orelse User{ .id = 0 };

// if 捕获
if (findUser(1)) |u| {
    std.debug.print("Found user: {}\n", .{u.id});
} else {
    std.debug.print("User not found\n", .{});
}

// .? - 断言非空（如果是 null 会 panic）
const definite_user = findUser(1).?;

3.6 控制流

if 语句：

// 基础 if
if (x > 0) {
    std.debug.print("positive\n", .{});
} else if (x < 0) {
    std.debug.print("negative\n", .{});
} else {
    std.debug.print("zero\n", .{});
}

// if 作为表达式
const abs = if (x < 0) -x else x;

// if 捕获 optional
if (optional_value) |value| {
    // value 是解包后的值
}

switch 语句：

const Result = enum { success, failure };

fn handleResult(res: Result) void {
    switch (res) {
        Result.success => std.debug.print("Success!\n", .{}),
        Result.failure => std.debug.print("Failure!\n", .{}),
    }
}

// 捕获值
const Value = union(enum) {
    int: i32,
    float: f64,
};

fn printValue(v: Value) void {
    switch (v) {
        Value.int => |i| std.debug.print("int: {}\n", .{i}),
        Value.float => |f| std.debug.print("float: {}\n", .{f}),
    }
}

// 多个 case
switch (number) {
    1, 2, 3 => std.debug.print("small\n", .{}),
    4, 5, 6 => std.debug.print("medium\n", .{}),
    else => std.debug.print("large\n", .{}),
}

循环：

// while 循环
var i: u32 = 0;
while (i < 10) : (i += 1) {
    std.debug.print("{}\n", .{i});
}

// for 循环
const array = [_]u32{1, 2, 3, 4, 5};
for (array) |item| {
    std.debug.print("{}\n", .{item});
}

// 带索引
for (array, 0..) |item, index| {
    std.debug.print("[{}] = {}\n", .{index, item});
}

// break 和 continue
while (true) {
    if (should_stop) break;
    if (skip_this) continue;
}

3.7 指针

// *T - 指向 T 的单项指针
// [*]T - 指向 T 的多项指针
// []T - 切片（指针 + 长度）

var x: u32 = 42;
const ptr: *u32 = &x;
std.debug.print("value: {}\n", .{ptr.*});  // 解引用

// 可选指针
const optional_ptr: ?*u32 = &x;

// 切片包含指针和长度
const array = [_]u32{1, 2, 3, 4, 5};
const slice: []const u32 = &array;

std.debug.print("len: {}, ptr: {*}\n", .{slice.len, slice.ptr});

第四部分：内存管理深度解析

4.1 Allocators（分配器）系统

Zig 使用显式分配器模式，既不是垃圾回收，也不是 RAII，而是显式的内存管理。

基础分配器使用：

const std = @import("std");

pub fn main() !void {
    // 1. 创建通用分配器
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    // 2. 分配内存
    const list = try allocator.alloc(u32, 10);
    defer allocator.free(list);  // 确保释放

    // 3. 使用内存
    for (list, 0..) |*item, i| {
        item.* = @intCast(i);
    }

    std.debug.print("{any}\n", .{list});
}

4.2 标准分配器类型

const std = @import("std");

pub fn main() !void {
    // 1. GeneralPurposeAllocator - 通用分配器
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer {
        const leaked = gpa.deinit();
        if (leaked == .leak) {
            std.debug.print("Memory leak detected!\n", .{});
        }
    }
    const allocator = gpa.allocator();

    // 2. ArenaAllocator - 批量分配，一次性释放
    var arena = std.heap.ArenaAllocator.init(allocator);
    defer arena.deinit();
    const arena_allocator = arena.allocator();

    // 所有分配从这里，自动清理
    const data1 = try arena_allocator.alloc(u8, 100);
    const data2 = try arena_allocator.alloc(u8, 200);

    // 3. FixedBufferAllocator - 固定大小缓冲区
    var buffer: [1024]u8 = undefined;
    var fixed_allocator = std.heap.FixedBufferAllocator.init(&buffer);
    const fixed = fixed_allocator.allocator();

    // 4. PageAllocator - 直接从操作系统分配页面
    const page_allocator = std.heap.page_allocator;
    const page_data = try page_allocator.alloc(u8, 4096);
    defer page_allocator.free(page_data);
}

4.3 defer 和 errdefer

defer - 作用域退出时执行：

fn openFile(path: []const u8) !std.fs.File {
    const file = try std.fs.cwd().openFile(path, .{});
    errdefer file.close();  // 如果出错则关闭

    // ... 处理文件 ...
    return file;
}

// 确保资源清理
fn process() !void {
    const file = try std.fs.cwd().openFile("data.txt", .{});
    defer file.close();  // 函数返回时自动关闭

    // 使用 file
}

errdefer - 仅在错误时执行：

fn processData(allocator: std.mem.Allocator) ![]u8 {
    const buffer = try allocator.alloc(u8, 1024);
    errdefer allocator.free(buffer);  // 只在出错时释放

    // 如果成功，buffer 将被返回或转移所有权

    // 如果这里出错，buffer 会被自动释放
    try validate(buffer);

    // 成功后，调用者负责释放
    return buffer;
}

4.4 内存安全最佳实践

const std = @import("std");

// ✅ 好：总是配对 alloc/free
fn goodPattern(allocator: std.mem.Allocator) ![]u32 {
    const data = try allocator.alloc(u32, 100);
    errdefer allocator.free(data);  // 出错时清理

    // ... 处理数据 ...
    return data;  // 转移所有权给调用者
}

// ✅ 好：使用 Arena 简化生命周期
fn processWithArena(allocator: std.mem.Allocator) !void {
    var arena = std.heap.ArenaAllocator.init(allocator);
    defer arena.deinit();  // 一次性释放所有

    const arena_alloc = arena.allocator();

    // 所有分配都从这里
    const data1 = try arena_alloc.alloc(u8, 100);
    const data2 = try arena_alloc.alloc(u8, 200);
    const data3 = try arena_alloc.alloc(u8, 300);

    // 无需手动释放
}

// ✅ 好：Debug 模式的安全检查
test "memory safety" {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer {
        const leaked = gpa.deinit();
        if (leaked == .leak) {
            std.debug.print("Memory leak detected!\n", .{});
        }
    }
    const allocator = gpa.allocator();

    // 运行测试
    // 如果有泄漏，会检测到
}

第五部分：错误处理机制

5.1 Error Sets 定义

// 定义错误集
const FileError = error{
    NotFound,
    PermissionDenied,
    IsDir,
};

// 函数返回错误
fn readFile(path: []const u8) FileError![]const u8 {
    const file = std.fs.cwd().openFile(path, .{}) catch |err| {
        return switch (err) {
            error.FileNotFound => FileError.NotFound,
            error.AccessDenied => FileError.PermissionDenied,
            else => err,
        };
    };
    defer file.close();

    // ... 读取文件 ...
    return &[_]u8{};
}

5.2 Error Union 操作符

try - 传播错误：

fn process() !void {
    // 如果 readFile 返回错误，立即返回
    const content = try readFile("data.txt");
    defer allocator.free(content);

    // 继续处理
}

catch - 捕获错误：

fn handle() void {
    const result = readFile("data.txt") catch |err| {
        std.debug.print("Error reading file: {}\n", .{err});
        return;
    };
    defer allocator.free(result);

    // 处理结果
}

// 提供默认值
const content = readFile("data.txt") catch &[_]u8{};

orelse - 处理 optional：

fn maybeReturn() ?[]const u8 {
    return null;  // 或返回值
}

fn use() void {
    const value = maybeReturn() orelse "default";
    std.debug.print("{s}\n", .{value});
}

5.3 错误处理最佳实践

const std = @import("std");

// ✅ 好：使用有意义的错误名
const AuthError = error{
    InvalidCredentials,
    AccountLocked,
    SessionExpired,
};

// ✅ 好：提供上下文信息
fn authenticate(user: []const u8, pass: []const u8) AuthError!Token {
    if (try validateCredentials(user, pass)) {
        return Token{ .user = user };
    }
    return AuthError.InvalidCredentials;
}

// ✅ 好：错误链
fn openConfig() !std.fs.File {
    const file = std.fs.cwd().openFile("config.json", .{}) catch |err| {
        std.log.err("Failed to open config file: {}", .{err});
        return err;
    };
    return file;
}

// ✅ 好：编译时确保处理所有错误
test "error handling" {
    const result = parseInt("42") catch |err| {
        std.testing.expect(err == ParseError.InvalidArgument);
        return;
    };
    _ = result;
}

第六部分：编译时执行（comptime）

6.1 comptime 基础

Zig 最强大的特性之一是编译时执行：

// comptime 变量 - 编译时常量
const size = comptime 10;  // 必须在编译时确定

// comptime 函数调用
fn factorial(n: u32) u32 {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

// 在编译时计算
const result = comptime factorial(5);  // 120，编译时计算

pub fn main() void {
    std.debug.print("factorial(5) = {}\n", .{result});
    // 运行时没有任何计算开销！
}

6.2 编译时类型操作

fn getTypeInfo(comptime T: type) void {
    std.debug.print("Size: {}\n", .{@sizeOf(T)});
    std.debug.print("Alignment: {}\n", .{@alignOf(T)});
    std.debug.print("Name: {s}\n", .{@typeName(T)});
}

test "type info" {
    comptime getTypeInfo(u32);
}

// 编译时类型检查
fn isInteger(comptime T: type) bool {
    return switch (@typeInfo(T)) {
        .Int => true,
        else => false,
    };
}

comptime {
    std.debug.print("isInteger(u32): {}\n", .{isInteger(u32)});
    std.debug.print("isInteger(f32): {}\n", .{isInteger(f32)});
}

6.3 泛型 via comptime

// 通用最大值函数
fn max(comptime T: type, a: T, b: T) T {
    return if (a > b) a else b;
}

test "generic max" {
    const i1: u32 = max(u32, 10, 20);
    const f1: f32 = max(f32, 1.5, 2.5);
    _ = i1;
    _ = f1;
}

// 通用容器
fn Stack(comptime T: type) type {
    return struct {
        items: []T,
        capacity: usize,
        len: usize,

        fn init(allocator: std.mem.Allocator, cap: usize) !@This() {
            const items = try allocator.alloc(T, cap);
            return .{
                .items = items,
                .capacity = cap,
                .len = 0,
            };
        }

        fn push(self: *@This(), allocator: std.mem.Allocator, item: T) !void {
            if (self.len >= self.capacity) return error.Overflow;
            self.items[self.len] = item;
            self.len += 1;
        }

        fn deinit(self: *@This(), allocator: std.mem.Allocator) void {
            allocator.free(self.items);
        }
    };
}

test "stack" {
    const std = @import("std");
    var stack = try Stack(u32).init(std.testing.allocator, 10);
    defer stack.deinit(std.testing.allocator);

    try stack.push(std.testing.allocator, 42);
}

6.4 anytype - 类型擦除

// anytype - 编译时泛型
fn printValue(value: anytype) void {
    std.debug.print("{}\n", .{value});
}

test "anytype" {
    printValue(42);       // i32
    printValue(3.14);     // f64
    printValue("hello");  // []const u8
}

// 约束 anytype
fn add(a: anytype, b: anytype) !@TypeOf(a, b) {
    const T = @TypeOf(a, b);

    // 编译时检查是否为数字类型
    comptime {
        if (!(@typeInfo(T) == .Int or @typeInfo(T) == .Float)) {
            @compileError("add requires numeric types");
        }
    }

    return a + b;
}

第七部分：交叉编译与 C 互操作

7.1 交叉编译

Zig 的交叉编译极其简单：

# 为不同目标编译
zig build-exe main.zig -target x86_64-linux-gnu
zig build-exe main.zig -target aarch64-macos-gnu
zig build-exe main.zig -target arm-linux-musleabihf
zig build-exe main.zig -target wasm32-wasi

# 查看所有目标
zig targets

# 为特定架构优化
zig build-exe main.zig -target x86_64-linux-gnu -mcpu=haswell

在 build.zig 中配置：

const std = @import("std");

pub fn build(b: *std.Build) void {
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});

    const exe = b.addExecutable(.{
        .name = "myapp",
        .root_source_file = .{ .path = "src/main.zig" },
        .target = target,
        .optimize = optimize,
    });

    b.installArtifact(exe);
}

7.2 C 互操作

导入 C 函数：

const c = @cImport({
    @cInclude("stdio.h");
    @cInclude("stdlib.h");
});

pub fn main() void {
    const msg = "Hello from C!\n";
    _ = c.printf("%s", msg);
}

定义 C ABI 函数：

// 导出函数供 C 调用
export extern "c" fn zigFunction(x: c_int) c_int {
    return x * 2;
}

// 使用 C 类型
const c_int = c_int;
const size_t = usize;

链接 C 库：

// build.zig
const exe = b.addExecutable(.{
    .name = "myapp",
    .root_source_file = .{ .path = "src/main.zig" },
    .target = target,
    .optimize = optimize,
});

// 链接系统库
exe.linkSystemLibrary("curl");
exe.linkSystemLibrary("ssl");
exe.linkSystemLibrary("crypto");

// 链接自定义库
exe.addIncludePath(.{ .path = "include" });
exe.addLibraryPath(.{ .path = "lib" });
exe.linkSystemLibrary("mylib");

7.3 Zig 作为 C 编译器

# Zig 替代 GCC/Clang
zig cc -o main main.c
zig c++ -o main main.cpp

# 交叉编译 C 代码
zig cc -target x86_64-windows-gnu -o main.exe main.c

# 使用 Zig 作为 sysroot
zig cc --sysroot /path/to/sysroot main.c

第八部分：构建系统和包管理

8.1 build.zig 基础

const std = @import("std");

pub fn build(b: *std.Build) void {
    // 标准选项
    const target = b.standardTargetOptions(.{});
    const optimize = b.standardOptimizeOption(.{});

    // 可执行文件
    const exe = b.addExecutable(.{
        .name = "myapp",
        .root_source_file = .{ .path = "src/main.zig" },
        .target = target,
        .optimize = optimize,
    });

    // 安装步骤
    b.installArtifact(exe);

    // 运行步骤
    const run_cmd = b.addRunArtifact(exe);
    run_cmd.step.dependOn(b.getInstallStep());

    const run_step = b.step("run", "Run the app");
    run_step.dependOn(&run_cmd.step);

    // 测试
    const unit_tests = b.addTest(.{
        .root_source_file = .{ .path = "src/main.zig" },
        .target = target,
        .optimize = optimize,
    });

    const run_unit_tests = b.addRunArtifact(unit_tests);
    const test_step = b.step("test", "Run unit tests");
    test_step.dependOn(&run_unit_tests.step);
}

8.2 包管理

创建 build.zig.zon（依赖清单）：

.{
    .name = "myproject",
    .version = "0.1.0",
    .dependencies = .{
        .zig_sqlite = .{
            .url = "https://github.com/vrischmann/zig-sqlite/archive/main.tar.gz",
            .hash = "1220f3b7c...",
        },
    },
}

添加依赖：

# 添加新依赖
zig fetch --save=dep_name https://example.com/dep.tar.gz

# 更新依赖
zig fetch --save=dep_name https://example.com/dep-v2.tar.gz

在 build.zig 中使用：

pub fn build(b: *std.Build) void {
    const dep = b.dependency("dep_name", .{
        .target = target,
        .optimize = optimize,
    });

    const module = dep.module("dep_module");
    exe.root_module.addImport("dep", module);
}

第九部分：测试框架

9.1 内置测试

const std = @import("std");

// 测试可以放在任何地方
test "addition" {
    const result = 2 + 2;
    try std.testing.expect(result == 4);
}

test "array operations" {
    const array = [_]u32{1, 2, 3, 4, 5};
    const slice = array[0..3];
    try std.testing.expectEqual(@as(usize, 3), slice.len);
}

// 测试错误
test "error handling" {
    const result = parseInt("abc") catch |err| {
        try std.testing.expect(err == ParseError.InvalidArgument);
        return;
    };
    try std.testing.expect(false);  // 不应该到达这里
}

9.2 测试模式

test "allocation" {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer {
        const leaked = gpa.deinit();
        try std.testing.expect(leaked == .ok);
    }
    const allocator = gpa.allocator();

    const data = try allocator.alloc(u32, 100);
    defer allocator.free(data);
}

// 编译时测试
comptime {
    const arr = arraySize(5);
    std.debug.print("Compile-time test: {any}\n", .{arr});
}

9.3 运行测试

# 运行所有测试
zig test src/main.zig

# 详细输出
zig test src/main.zig --summary all

# 只运行特定测试
zig test src/main.zig --test-filter "addition"

# 使用 build system
zig build test

第十部分：实际应用案例

10.1 HTTP 服务器

const std = @import("std");

pub fn main() !void {
    const address = try std.net.Address.parseIp("127.0.0.1", 8080);
    var listener = try address.listen(.{
        .reuse_address = true,
    });
    defer listener.deinit();

    std.debug.print("Server listening on {}\n", .{address});

    while (true) {
        const connection = try listener.accept();
        std.debug.print("New connection from {}\n", .{connection.address});

        // 处理连接
        handleConnection(connection) catch |err| {
            std.log.err("Connection error: {}", .{err});
        };
    }
}

fn handleConnection(conn: std.net.Server.Connection) !void {
    defer conn.stream.close();

    var buffer: [1024]u8 = undefined;
    const bytes_read = try conn.stream.read(&buffer);

    // 简单的 HTTP 响应
    const response = "HTTP/1.1 200 OK\r\n\r\nHello, World!\r\n";
    _ = try conn.stream.writeAll(response);
}

10.2 嵌入式开发

// 嵌入式目标
// zig build-exe embedded.zig -target thumb-freestanding-eabi

const std = @import("std");

export fn resetHandler() callconv(.C) noreturn {
    // 初始化硬件
    initHardware();

    // 主循环
    while (true) {
        // GPIO 操作
        gpioToggle(GPIO_PIN_13);
        delay(1000);
    }
}

fn initHardware() void {
    // 设置寄存器
    const GPIO_BASE = 0x40020000;
    const GPIO_MODER = @ptrFrom([*]volatile u32, GPIO_BASE + 0x00);
    GPIO_MODER.* = 0x400000;  // 设置 GPIO 为输出
}

fn gpioToggle(pin: u32) void {
    const GPIO_ODR = @ptrFrom([*]volatile u32, 0x40020014);
    GPIO_ODR.* ^= (1 << pin);
}

fn delay(ms: u32) void {
    const HZ = 16_000_000;  // 16 MHz
    const cycles = ms * (HZ / 1000);
    var i: u32 = 0;
    while (i < cycles) : (i += 1) {
        asm volatile ("" ::: "memory");
    }
}

10.3 WebAssembly

// 编译为 WebAssembly
// zig build-exe wasm.zig -target wasm32-wasi -O ReleaseFast

export fn add(a: i32, b: i32) i32 {
    return a + b;
}

export fn fibonacci(n: i32) i32 {
    if (n <= 1) return n;
    return fibonacci(n - 1) + fibonacci(n - 2);
}

export fn process(data: [*]u8, len: usize) usize {
    var sum: usize = 0;
    var i: usize = 0;
    while (i < len) : (i += 1) {
        sum += data[i];
    }
    return sum;
}

第十一部分：性能优化

11.1 编译优化模式

# Debug - 快速编译，无优化
zig build-exe main.zig -O Debug

# ReleaseFast - 最大优化
zig build-exe main.zig -O ReleaseFast

# ReleaseSafe - 优化 + 安全检查
zig build-exe main.zig -O ReleaseSafe

# ReleaseSmall - 最小二进制
zig build-exe main.zig -O ReleaseSmall

11.2 性能测量

const std = @import("std");

fn benchmark(comptime func: fn() void, iterations: usize) void {
    const timer = std.time.Timer.start() catch unreachable;

    var i: usize = 0;
    while (i < iterations) : (i += 1) {
        func();
    }

    const elapsed_ns = timer.read();
    const avg_ns = elapsed_ns / iterations;

    std.debug.print("{} iterations in {} ns (avg: {} ns)\n",
        .{iterations, elapsed_ns, avg_ns});
}

test "performance" {
    benchmark(someFunction, 1000);
}

11.3 内联提示

// 提示编译器内联
inline fn fastAdd(a: u32, b: u32) u32 {
    return a + b;
}

// 编译时强制内联
fn alwaysInline(x: u32) u32 {
    @setRuntimeSafety(false);
    return x * 2;
}

第十二部分：工具和 IDE 支持

12.1 Zig Language Server (ZLS)

ZLS 是 Zig 的官方语言服务器，提供：

自动补全
跳转到定义
错误检查
代码格式化

安装 ZLS：

# 从源码构建
git clone https://github.com/zigtools/zls.git
cd zls
zig build -Doptimize=ReleaseSafe

12.2 VSCode 配置

推荐扩展：

ziglang.vscode-zig - 官方扩展

settings.json：

{
    "zig.zls.path": "path/to/zls",
    "zig.buildOnSave": true,
    "zig.zls.enableSnippets": true,
    "zig.zls.enableArgumentPlaceholders": true,
    "[zig]": {
        "editor.formatOnSave": true
    }
}

12.3 Neovim 配置

-- init.lua
vim.filetype.add({
  extension = {
    zig = 'zig',
  },
})

-- LSP 配置
require('lspconfig').zls.setup({
    cmd = {'path/to/zls'},
    settings = {
        zls = {
            enable_snippets = true,
            enable_argument_placeholders = true,
        }
    }
})

第十三部分：生态系统

13.1 热门项目和库

ziglings - 互动式 Zig 教程
zig-upaya - Web 框架
zql - 数据库库
mach - 游戏引擎框架
tigerbeetle - 金融交易系统（用 Zig 编写）

13.2 社区资源

Awesome Zig - 精选项目列表
Zigistry - 包注册表
Ziggit - 官方论坛
Zig 中文社区 - 中文学习资源

13.3 实际采用案例

2025 年的成功案例：

TigerBeetle - 金融交易系统，处理数百万笔交易
Bun - JavaScript 运行时，部分组件使用 Zig
多个游戏引擎 - 高性能图形渲染
嵌入式系统 - 从微控制器到物联网设备

第十四部分：学习路径和资源

14.1 官方文档

14.2 中文资源

14.3 推荐学习路径

初学者：

阅读官方 Getting Started
完成 ziglings 练习
阅读 Zig 语言圣经
实践小项目

进阶：

深入学习 comptime
研究 Zig 标准库实现
参与开源项目
构建复杂应用

14.4 练习项目

入门级：

实现基础数据结构（栈、队列、链表）
编写 JSON 解析器
实现简单的文本编辑器

中级：

HTTP 服务器
文件系统工具
数据库客户端

高级：

编译器/解释器
操作系统内核
游戏引擎

第十五部分：未来展望

15.1 Zig 1.0 发布计划

Zig 目前处于活跃开发阶段，1.0 版本预计在 2026 年发布。

当前状态：

核心特性基本稳定
标准库持续完善
工具链成熟度提升
社区快速增长

15.2 2025 年的改进

异步 I/O 接口稳定 - 新的异步模型
编译器性能优化 - 更快的编译速度
语言服务器改进 - 更好的 IDE 支持
包管理系统完善 - 更成熟的依赖管理
更多平台支持 - 扩展交叉编译能力

15.3 发展方向

Zig 的设计哲学和特性使其在以下领域具有巨大潜力：

系统编程 - 替代 C/C++
嵌入式开发 - 交叉编译优势
WebAssembly - 编译为 WASM 的优秀选择
工具链 - 作为 C/C++ 编译器
教育 - 学习系统编程的现代语言

总结

Zig 是一个野心勃勃的现代系统编程语言，它试图：

✅ 保持 C 的简洁性和性能
✅ 提供更好的安全性和开发体验
✅ 简化交叉编译和工具链
✅ 通过编译时执行提升性能
✅ 提供优秀的 C 互操作

关键优势：

学习曲线适中 - 比 Rust 简单，比 C 现代化
性能接近 C - 零成本抽象
单一工具链 - 一个命令处理所有任务
交叉编译简单 - 无需额外配置
活跃的社区 - 快速增长的生态系统

是否选择 Zig？

选择 Zig 如果：

需要系统编程的高性能
想要比 C 更安全的语言
需要交叉编译到多个平台
想要与 C/C++ 代码集成
关注编译时计算和优化

可能不适合如果：

需要垃圾回收
想要快速原型开发
团队已经熟悉 Rust
需成熟的企业级支持（相比 Rust/Go）

最终建议：

Zig 是一个值得关注的现代系统编程语言。虽然还在发展中，但它的设计理念和实现已经证明了自己的价值。如果你对系统编程、性能优化或编译器技术感兴趣，Zig 绝对值得学习和探索。

资源链接

官方资源

学习资源

社区

最后提醒：Zig 还在快速发展中，API 可能会有变化。关注官方发布说明和迁移指南，及时更新代码。最重要的是，动手实践——编写代码、构建项目、参与社区，这是掌握 Zig 的最佳方式。

Systems-programming