Skip to content

Zig Aide-mémoire

Langage de programmation généraliste et toolchain pour des programmes robustes et optimaux.

01

Premiers pas

Hello World

Zig utilise @import pour la std lib ; print utilise des chaînes de format à la comptime.

zig
const std = @import("std");

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

Variables

const est immuable, var est mutable. Les types sont explicites ou inférés.

zig
const x: i32 = 10;
var y: i32 = 20;
y += 5;

Fonctions

Les fonctions utilisent le mot-clé fn ; pub les rend publiques.

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

pub fn main() void {
    const std = @import("std");
    std.debug.print("{d}\n", .{add(3, 4)});
}

Build

Zig possède un système de build intégré et la compilation croisée.

zig
# zig build-exe main.zig
# zig run main.zig
02

Types

Entiers

Zig possède des entiers de largeur de bit arbitraire : i8, u8, i16, u16, i32, u32, etc.

zig
const a: u8 = 255;
const b: i32 = -100;
const c: usize = 0;

Tableaux

[_] infère la longueur du tableau.

zig
const arr = [_]i32{ 1, 2, 3, 4, 5 };
const first = arr[0];
const len = arr.len;

Slices

Les slices sont des vues sur des tableaux ; .. est une fin exclusive.

zig
const arr = [_]i32{ 1, 2, 3, 4, 5 };
const slice = arr[1..4]; // [2, 3, 4]

Optionals

?T est un type optionnel ; utilisez .? ou if-let pour le déballer (unwrap).

zig
var maybe: ?i32 = null;
maybe = 42;
if (maybe) |val| {
    // val is i32 here
}
03

Flux de contrôle

If-Else

Les if-else sont des expressions en Zig.

zig
const x: i32 = 5;
if (x > 3) {
    // big
} else {
    // small
}

Switch

Le switch doit être exhaustif.

zig
const x: u8 = 2;
switch (x) {
    1 => {},
    2 => {},
    else => {},
}

While

Le : (i += 1) est l'expression de continuation.

zig
var i: u32 = 0;
while (i < 5) : (i += 1) {
    // loop body
}

For

For itère sur des slices/tableaux.

zig
const arr = [_]i32{ 1, 2, 3 };
for (arr) |val| {
    // use val
}
04

Mémoire

Allocators

Zig n'a pas d'allocations cachées ; les allocators sont explicites.

zig
const std = @import("std");
pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    const allocator = gpa.allocator();
    const slice = try allocator.alloc(u8, 100);
    defer allocator.free(slice);
}

Defer

defer s'exécute à la sortie de la portée — nettoyage de ressources façon RAII.

zig
const std = @import("std");
pub fn main() void {
    const file = std.fs.cwd().createFile("test.txt", .{}) catch unreachable;
    defer file.close();
}

Was this helpful?