¿Qué es un zig language reference?

Cuando comienzas a programar en Zig, una de las herramientas más valiosas que encontrarás es la documentación oficial que se conoce como language reference. Este recurso es el punto de partida para comprender a fondo la sintaxis, los tipos, las convenciones y las peculiaridades que hacen único al lenguaje.

¿Qué es una referencia del lenguaje Zig?

La referencia del lenguaje Zig es el documento central que describe con precisión todas las construcciones disponibles en Zig. Se compone de secciones que abordan la gramática, los tipos primitivos, las funciones, los módulos, la gestión de errores, la interoperabilidad con C, y mucho más. Su propósito es ser la fuente definitiva y oficial para programadores, tanto principiantes como expertos.

Estructura típica de la referencia

Gramática: reglas de sintaxis y parseo.
Tipos: primitivos, compuestos, genéricos y opcionales.
Control de flujo: condicionales, bucles y saltos.
Funciones y métodos: definición, llamada y sobrecarga.
Errores: manejo con error y try/else.
Almacén y memoria: asignación, deallocación y punteros.
Interoperabilidad con C: extern y tipos compatibles.
Conjuntos de pruebas: ejemplos de uso y patrones de diseño.

Cómo navegar la referencia

La referencia se organiza de manera jerárquica:

Índice de palabras clave – búsqueda rápida de conceptos.
Sección de tipos – incluye tablas comparativas.
Ejemplos y casos de uso – ilustraciones prácticas.
Glosario – definiciones de términos técnicos.

Además, la versión en línea permite buscar con palabras clave y explorar enlaces internos que llevan a secciones relacionadas.

Ejemplo práctico: declaración de variables

// Declarar una constante de tipo entero
const myConst: i32 = 42;

// Declarar una variable mutable de tipo flotante
var myFloat: f64 = 3.1415;

// Declarar un puntero a entero
var ptr: *i32 = &myConst;

// Acceder a la variable a través del puntero
var valueAtPtr: i32 = ptr.*; // Dereferencia el puntero

Desglose línea por línea:

const myConst: i32 = 42; – const define una constante; i32 es un entero de 32 bits; 42 es el valor inicial.
var myFloat: f64 = 3.1415; – var declara una variable mutable; f64 es un flotante de 64 bits.
var ptr: *i32 = &myConst; – *i32 indica un puntero a i32; &myConst obtiene la dirección de memoria de myConst.
var valueAtPtr: i32 = ptr.*; – ptr.* desreferencia el puntero para obtener el valor apuntado.

Ejemplo avanzado: manejo de errores

// Definimos un conjunto de errores posibles
const MyError = error{
    NotFound,
    InvalidInput,
};

// Función que puede fallar, retornando un error o un valor
fn divide(a: i32, b: i32) !i32 {
    // Si el divisor es cero, retornamos el error NotFound
    if (b == 0) return MyError.NotFound;
    // De lo contrario, devolvemos el resultado de la división
    return a / b;
}

// Código cliente que llama a la función y maneja los errores
pub fn main() !void {
    // Intentamos dividir 10 entre 0, esperando un error
    const result = divide(10, 0) catch |err| {
        // En caso de error, imprimimos el mensaje y retornamos
        std.debug.print("Error: {}\n", .{err});
        return err; // Propagamos el error hacia arriba
    };
    // Si no hubo error, mostramos el resultado
    std.debug.print("Resultado: {}\n", .{result});
}

Detalle de cada línea:

const MyError = error{ NotFound, InvalidInput }; – Creamos un conjunto de errores que podemos usar en funciones.
fn divide(a: i32, b: i32) !i32 { – La función devuelve i32 o un error (el signo de exclamación indica posibilidad de error).
if (b == 0) return MyError.NotFound; – Verificamos si el divisor es cero y devolvemos un error específico.
return a / b; – Si el divisor es válido, devolvemos la división.
const result = divide(10, 0) catch |err| { – Llamamos a la función y capturamos cualquier error con catch.
std.debug.print("Error: {}\n", .{err}); – Imprimimos el error usando el sistema de impresión de Zig.
return err; – Propagamos el error hacia el llamador.
std.debug.print("Resultado: {}\n", .{result}); – Si la operación fue exitosa, mostramos el resultado.

Conclusión

La referencia del lenguaje Zig es tu mapa completo para navegar todas las facetas del lenguaje. Al dominarla, podrás escribir código más robusto, aprovechar al máximo las características de Zig y evitar errores comunes. Dedica tiempo a leer y experimentar con los ejemplos, y pronto sentirás que el lenguaje se convierte en una extensión natural de tu pensamiento.