Zig 语法指南

const std = @import("std");

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

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

// 可变变量
var x: i32 = 10;
x = 20;

// 不可变变量
const y: i32 = 30;
// y = 40; // 编译错误

// 类型推断
var name = "Zig";
const version = 0.15;

// 可变变量
var x int = 10
x = 20

// 不可变变量
const y int = 30
// y = 40 // 编译错误

// 类型推断
name := "Go"
const version = 1.21

// 固定大小数组
const arr: [5]i32 = [1, 2, 3, 4, 5];

// 切片（指针 + 长度）
var slice: []i32 = arr[1..4];

// 字符串切片
const msg: []const u8 = "Hello";

// 动态数组
var list = std.ArrayList(i32).init(allocator);
defer list.deinit();

// 固定大小数组
var arr [5]int = [5]int{1, 2, 3, 4, 5}

// 切片（动态数组）
slice := []int{1, 2, 3, 4, 5}
subslice := slice[1:4]

// 字符串
msg := "Hello"

// 动态数组（切片的底层）
list := make([]int, 0, 10)

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

// 多返回值
fn divide(a: i32, b: i32) struct { i32, i32 } {
    return .{ a / b, a % b };
}

// 泛型函数
fn max(comptime T: type, a: T, b: T) T {
    if (a > b) return a;
    return b;
}

// 基本函数
func add(a int, b int) int {
    return a + b
}

// 多返回值
func divide(a int, b int) (int, int) {
    return a / b, a % b
}

// 泛型函数（Go 1.18+）
func max[T comparable](a T, b T) T {
    if a > b {
        return a
    }
    return b
}

const x = 10;

if (x > 5) {
    std.debug.print("大于5\n", .{});
} else if (x == 5) {
    std.debug.print("等于5\n", .{});
} else {
    std.debug.print("小于5\n", .{});
}

// switch 语句
switch (x) {
    0...5 => std.debug.print("0-5\n", .{}),
    6...10 => std.debug.print("6-10\n", .{}),
    else => std.debug.print("其他\n", .{}),
}

x := 10

if x > 5 {
    fmt.Println("大于5")
} else if x == 5 {
    fmt.Println("等于5")
} else {
    fmt.Println("小于5")
}

// switch 语句
switch x {
case 0, 1, 2, 3, 4, 5:
    fmt.Println("0-5")
case 6, 7, 8, 9, 10:
    fmt.Println("6-10")
default:
    fmt.Println("其他")
}

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

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

// 带索引的循环
for (arr, 0..) |value, index| {
    std.debug.print("{}: {d}\n", .{ index, value });
}

// for 循环（Go 只有 for）
for i := 0; i < 5; i++ {
    fmt.Println(i)
}

// range 循环
arr := []int{1, 2, 3, 4, 5}
for _, value := range arr {
    fmt.Println(value)
}

// 带索引的 range
for index, value := range arr {
    fmt.Printf("%d: %d\n", index, value)
}

const std = @import("std");

pub fn main() !void {
    // 创建分配器
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer std.debug.assert(gpa.deinit() == .ok);
    
    const allocator = gpa.allocator();
    
    // 分配内存
    const buffer = try allocator.alloc(u8, 1024);
    defer allocator.free(buffer);
    
    // 使用内存
    @memcpy(buffer[0..5], "Hello");
    std.debug.print("{s}\n", .{buffer[0..5]});
}

package main

import "fmt"

func main() {
    // 自动分配内存
    buffer := make([]byte, 1024)
    
    // 使用内存
    copy(buffer[0:5], "Hello")
    fmt.Println(string(buffer[0:5]))
    
    // GC 自动清理
}

const std = @import("std");

// 定义错误
const Error = error{
    DivisionByZero,
    Overflow,
};

// 返回错误联合类型
fn divide(a: i32, b: i32) Error!i32 {
    if (b == 0) {
        return Error.DivisionByZero;
    }
    return a / b;
}

pub fn main() !void {
    // 使用 try 传播错误
    const result = try divide(10, 2);
    
    // 显式错误处理
    const err_result = divide(10, 0);
    if (err_result) |value| {
        std.debug.print("Success: {}\n", .{value});
    } else |err| {
        std.debug.print("Error: {}\n", .{err});
    }
}

package main

import (
    "errors"
    "fmt"
)

// 定义错误
var ErrDivisionByZero = errors.New("division by zero")
var ErrOverflow = errors.New("overflow")

// 返回错误作为第二个值
func divide(a int, b int) (int, error) {
    if b == 0 {
        return 0, ErrDivisionByZero
    }
    return a / b, nil
}

func main() {
    // 显式错误处理
    result, err := divide(10, 2)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Printf("Success: %d\n", result)
}