基础语法:用 Go/Rust 经验快速上手 Zig

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

const std = @import("std");

pub fn main() void {
    // 常量（不可变）- 优先使用
    const pi: f64 = 3.14159;
    const name = "Zig"; // 类型推断

    // 变量（可变）
    var count: i32 = 0;
    count += 1;

    // 未定义值（类似 Rust 的 MaybeUninit）
    var x: i32 = undefined;
    x = 42;
}

1
2
3
4

fn max(a: i32, b: i32) i32 {
    // if 是表达式,可以返回值
    return if (a > b) a else b;
}

1
2
3
4
5
6
7
8

fn doSomething() !void {
    const result = mayFail();
    if (result) |value| {
        // 成功,value 是成功值
    } else |err| {
        // 失败,err 是错误
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

const Color = enum { red, green, blue };

fn colorToString(c: Color) []const u8 {
    return switch (c) {
        .red => "红色",
        .green => "绿色",
        .blue => "蓝色",
    };
}

// 范围匹配
fn classify(n: i32) []const u8 {
    return switch (n) {
        0 => "零",
        1...9 => "个位数",
        10...99 => "两位数",
        else => "其他",
    };
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

pub fn main() void {
    // for 循环（遍历切片）
    const items = [_]i32{ 1, 2, 3, 4, 5 };
    for (items) |item| {
        std.debug.print("{}\n", .{item});
    }

    // 带索引的 for 循环
    for (items, 0..) |item, i| {
        std.debug.print("[{}] {}\n", .{i, item});
    }

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

    // 带续行表达式的 while
    var sum: i32 = 0;
    var j: i32 = 1;
    while (j <= 100) : (j += 1) {
        sum += j;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

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

// 多返回值（通过匿名结构体）
fn divide(a: f64, b: f64) struct { quotient: f64, remainder: f64 } {
    return .{
        .quotient = a / b,
        .remainder = @mod(a, b),
    };
}

// 泛型函数（使用 comptime 类型参数）
fn genericAdd(comptime T: type, a: T, b: T) T {
    return a + b;
}

// 调用
const result = genericAdd(i32, 1, 2);
const fresult = genericAdd(f64, 1.5, 2.5);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// 使用 anytype 的泛型函数
fn add(a: anytype, b: @TypeOf(a)) @TypeOf(a) {
    return a + b;
}

// 使用 @TypeOf 获取类型信息
fn printType(value: anytype) void {
    std.debug.print("类型: {}\n", .{@TypeOf(value)});
}

pub fn main() void {
    // 自动推断类型
    const int_result = add(1, 2);      // i32
    const float_result = add(1.5, 2.5); // f64

    printType(42);     // 类型: comptime_int
    printType("hello"); // 类型: *const [5:0]u8
}