Zig Programming Language Cheatsheet

Zig is a modern programming language designed for simplicity, performance, and reliability. With a focus on low-level programming and system-level development, Zig has gained popularity for its clear syntax, zero-cost abstractions, and emphasis on developer control. This cheatsheet serves as a quick reference guide for programmers looking to get started with Zig or those who want a handy reference for its key features.

Hello, World!

const std = @import("std");

pub fn main() void {
    std.debug.print("Hello, {}!\n", .{"world"});
}

Basics

Comments

// This is a single-line comment

/*
   This is a
   multi-line comment
*/

Variables

const x: i32 = 42;
var y: f64 = 3.14;

Constants

const Pi: f64 = 3.14159265359;

Strings

const message = "Hello, Zig!";
const interpolated_message = "The value of x is {}.\n".format(x);

Control Flow

If Statement

if x > 10 {
    // Code here
} else if x < 0 {
    // Code here
} else {
    // Code here
}

Switch Statement

switch x {
    1 => // Code here
    2 | 3 => // Code here for 2 or 3
    else => // Code here for other cases
}

Loop

while x > 0 : (x -= 1) {
    // Code here
}

Functions

Function Declaration

fn add(x: i32, y: i32) i32 {
    return x + y;
}

Anonymous Functions

const add = fn(x: i32, y: i32) i32 {
    return x + y;
};

Variadic Functions

fn printNumbers(#[noalias] nums: i32...) void {
    // Code here
}

Error Handling

Option Type

const std = @import("std");

const Result = std.Result;

fn divide(x: f64, y: f64) Result(f64, "cannot divide by zero") {
    if y == 0.0 {
        return Result.Error("cannot divide by zero");
    }
    return Result.Ok(x / y);
}

Custom Error Union

const std = @import("std");

const MyError = std.MyError;

pub fn divide(x: f64, y: f64) !f64 {
    if y == 0.0 {
        return MyError.DivideByZero;
    }
    return x / y;
}

Memory Management

Allocating Memory

const allocator = std.testing.allocator;

const ptr = allocator.alloc(u8, 10);

Deallocating Memory

allocator.free(u8, ptr, 10);

Structs and Enums

Struct Declaration

const Point = struct {
    x: f64,
    y: f64,
};

Enum Declaration

const Result = enum {
    Ok,
    Err,
};

Concurrency

Async Functions

const std = @import("std");

pub fn asyncMain() void {
    const result = async {
        // Async code here
        return 42;
    };
    std.debug.print("Result: {}\n", .{result});
}

Channels

const std = @import("std");

const Channel = std.Channel;

pub fn main() void {
    const channel = Channel(i32).init(std.testing.allocator);

    go async {
        await channel.send(42);
    };

    const value = await channel.receive();
    std.debug.print("Received: {}\n", .{value});
}

This Zig programming language cheatsheet provides a quick overview of essential features and syntax elements. Use it as a reference to accelerate your Zig programming journey. For more in-depth information, be sure to consult the official Zig documentation at ziglang.org.

FAQ