Descripción general del lenguaje Zig

Zig 0.14 — lenguaje de sistemas | sin flujo de control oculto | sin asignaciones ocultas | sin preprocesador | ejecución en tiempo de compilación

paradigma

Imperativo, procedimental, orientado a datos. Escritura estática con inferencia, escritura estructural (pato) mediante comptime. Compilación a través de LLVM + backend autohospedado. Sin sobrecarga de operadores, sin excepciones, sin RAII, sin macros.

Tipos

Declaraciones

Controlar el flujo

Funciones del interruptor

• Exhaustividad comprobada en tiempo de compilación
• Varios artículos por brazo: 1, 2 => ...
• Brazos de alcance: 0...10 => ...
• Capturar nombres de puntas: inline else => \|tag\| ...

Operadores

Comptime (metaprogramación)

fn max(comptime T: type, a: T, b: T) T {
    return if (a > b) a else b;
}

comptime {
    // Runs at compile time
    @compileLog("building for", @tagName(builtin.cpu));
}

// Generics via comptime parameters
fn ArrayList(comptime T: type) type {
    return struct {
        items: []T,
        fn init(self: *Self) void { ... }
    };
}

Funciones de tiempo completo

• comptime los bloques se ejecutan durante la compilación
• comptime Los parámetros de la función se conocen en tiempo de compilación.
• inline for / inline while desenrolla bucles en tiempo de compilación
• @Type(...) tipos de construcción en tiempo de compilación
• @fieldParentPtr búsqueda de campo inverso
• @hasDecl @hasField reflexión en tiempo de compilación
• @typeInfo obtiene información de tipo como estructura

Memoria

Asignadores

std.heap.page_allocator std.heap.arena_allocator std.heap.FixedBufferAllocator std.heap.ArenaAllocator std.heap.StackFallbackAllocator std.heap.c_allocator

La filosofía del asignador de Zig

• Cada asignación toma un parámetro de asignación explícito
• Sin asignador global, sin asignaciones implícitas
• Los asignadores componen (grupo → arena → página)

Manejo de errores

// Error union type: ReturnType!Error
fn div(a: i32, b: i32) !i32 {
    if (b == 0) return error.DivisionByZero;
    return a / b;
}

// Try operator: early return on error
const result = try div(10, 2);

// Catch: provide default
const val = div(10, 0) catch 0;

// Global error set vs specific
fn parse() ParseError!i32 { ... }

Aplazar y Errdefer

{
    const buf = try allocator.alloc(u8, 100);
    defer allocator.free(buf);  // always runs at scope exit
    errdefer allocator.free(buf);  // runs only if error returned

    // ... use buf
}  // defer triggers here

Biblioteca estándar (seleccionada)

Pruebas

test "basic addition" {
    try std.testing.expectEqual(4, add(2, 2));
    try std.testing.expect(add(1, 1) == 2);
    try std.testing.expectError(error.DivisionByZero, div(1, 0));
}

zig test file.zig        # run tests
zig build test           # run all tests in project
zig test --name "filter" # filter test names

Compilación cruzada

zig build-exe main.zig --target x86_64-windows  # cross-compile to Windows
zig build-exe main.zig --target aarch64-linux    # cross-compile to ARM64 Linux
zig build-exe main.zig --target riscv64-linux    # cross-compile to RISC-V

Zig se entrega con encabezados libc y cadenas de herramientas de compilación cruzada para todos los objetivos principales; no se necesita un compilador cruzado separado.

Interoperabilidad C

// Import C header
const c = @cImport({
    @cInclude("stdio.h");
});

// Link C library
pub fn main() void {
    _ = c.printf("hello %d\n", 42);
}

// Direct use of C ABI
extern "c" fn strlen(s: [*:0]u8) usize;

// Zig is a better C:
// - @cImport for headers
// - export fn for C-ABI exports
// - [*:0]T for null-terminated strings
// - @ptrCast for pointer conversion
// - packed struct for ABI-compatible layouts

Diferencias notables con C

• Sin preprocesador (use comptime)
• Sin conversiones implícitas (explícitas @intCast @floatCast)
• Sin UB de forma predeterminada (comprobaciones de seguridad en depuración, suscripción voluntaria @setRuntimeSafety)
• defer reemplaza goto cleanup patrones
• anytype reemplaza a void* + macro genéricos
• El tipo de matriz incluye la longitud ([N]T vs T[N])
• undefined en lugar de no inicializado
• null de opcional ?*T, no puntero

Compilación

zig build-exe main.zig     # compile executable
zig build-lib lib.zig       # compile library
zig build-obj obj.zig       # compile object
zig run main.zig            # compile + run
zig test file.zig           # compile + run tests
zig fmt file.zig            # format code
zig build                   # build project (build.zig)
zig translate-c foo.h       # translate C header to Zig

Modos de construcción