Zig es un lenguaje de programación moderno de propósito general diseñado para ser robusto, óptimo y mantenible. Con un enfoque en la simplicidad y la claridad, Zig proporciona control de bajo nivel al tiempo que evita el flujo de control y las asignaciones ocultas. Este tutorial te guiará a través del proceso de instalación, la creación de tu primer programa Zig y la ejecución de pruebas. Al final, tendrás una base sólida para explorar este poderoso lenguaje más a fondo.
Mientras exploramos potentes herramientas para desarrolladores, vale la pena mencionar Apidog, la alternativa definitiva a Postman para el desarrollo y las pruebas de API. Apidog combina la documentación, el diseño, la simulación, las pruebas y la depuración de API en una única plataforma optimizada.
Con su interfaz intuitiva, sus funciones de colaboración y su perfecta integración del control de versiones, Apidog mejora drásticamente la eficiencia del flujo de trabajo para los desarrolladores que trabajan con API. Su completo conjunto de funciones incluye pruebas automatizadas, gestión del entorno, encadenamiento de solicitudes y validación inteligente de respuestas, lo que la convierte en una herramienta esencial para los equipos de desarrollo modernos.
Antes de sumergirte en la programación de Zig, considera agregar Apidog a tu conjunto de herramientas de desarrollador para mejorar tu productividad general cuando trabajes con API y servicios web.
Parte 1: Instalación de Zig
Antes de que puedas comenzar a programar en Zig, debes instalar el compilador y las herramientas. El proceso de instalación varía según tu sistema operativo.
Instalación en Linux
Tienes dos opciones principales para instalar Zig en Linux:
Opción 1: Usar el administrador de paquetes de tu distribución
La mayoría de las principales distribuciones de Linux empaquetan la última versión de Zig. Este es a menudo el enfoque más fácil:
# For Debian/Ubuntu
sudo apt install zig
# For Fedora
sudo dnf install zig
# For Arch Linux
sudo pacman -S zig
Opción 2: Instalación manual
Si tu distribución no tiene Zig o necesitas una versión específica:
Descarga una versión precompilada de Zig del sitio web oficial que coincida con la arquitectura de tu CPU
Para verificar tu arquitectura, usa:
uname -m
Extrae el archivo usando tar:
tar xf zig-linux-x86_64-0.13.0.tar.xz
Agrega el binario de Zig a tu PATH:
echo 'export PATH="$HOME/zig-linux-x86_64-0.13.0:$PATH"' >> ~/.bashrc
Aplica los cambios:
source ~/.bashrc
Instalación en Windows
Los usuarios de Windows tienen varias opciones:
Opción 1: Usar administradores de paquetes
# Using Chocolatey
choco install zig
# Using Winget
winget install zig.zig
# Using Scoop
scoop install zig
Opción 2: Instalación manual
Descarga una versión precompilada de Zig para Windows que coincida con la arquitectura de tu CPU (la mayoría de los sistemas Windows usan x86_64/AMD64)
Verifica tu arquitectura con:
$Env:PROCESSOR_ARCHITECTURE
Extrae el archivo ZIP
Agrega Zig a tu PATH:
Para el usuario actual:
[Environment]::SetEnvironmentVariable(
"Path",
[Environment]::GetEnvironmentVariable("Path", "User") + ";C:\\\\path\\\\to\\\\zig-windows-x86_64",
"User"
)
Para todo el sistema:
[Environment]::SetEnvironmentVariable(
"Path",
[Environment]::GetEnvironmentVariable("Path", "Machine") + ";C:\\\\path\\\\to\\\\zig-windows-x86_64",
"Machine"
)
Cierra y vuelve a abrir tu terminal
Instalación en macOS
La forma más sencilla de instalar Zig en macOS es usar Homebrew:
brew install zig
Verificación de tu instalación
Después de la instalación, verifica que Zig esté instalado correctamente ejecutando:
zig version
Deberías ver una salida como:
0.13.0
Parte 2: ¡Hola, Mundo! en Zig
Ahora que Zig está instalado, creemos tu primer programa Zig: el tradicional ejemplo "¡Hola, Mundo!".
Creación del archivo del programa
- Crea un nuevo archivo llamado
main.zig - Ábrelo en tu editor de texto preferido
- Agrega el siguiente código:
const std = @import("std");
pub fn main() void {
std.debug.print("Hello, {s}!\\\\n", .{"World"});
}
Analicemos lo que hace este código:
const std = @import("std");importa la biblioteca estándar de Zigpub fn main() void {declara la función principal que actúa como punto de entrada de tu programastd.debug.print("Hello, {s}!\\\\n", .{"World"});imprime "¡Hola, Mundo!" en el flujo de error estándar (stderr){s}es un especificador de formato para cadenas, y.{"World"}es cómo Zig pasa argumentos a los especificadores de formato
Ejecución del programa
Para construir y ejecutar tu programa, usa el siguiente comando:
zig run main.zig
Esto compila tu código y lo ejecuta inmediatamente. Deberías ver la salida:
Hello, World!
Nota importante sobre la codificación de archivos
Zig requiere codificación UTF-8 para los archivos fuente. Si encuentras un error como invalid bytes, es posible que tu archivo tenga una codificación diferente. Para solucionar esto:
zig fmt main.zig
Esto volverá a codificar tu archivo como UTF-8. Luego, vuelve a abrir el archivo en tu editor.
Parte 3: Ejecución de pruebas en Zig
Zig tiene un marco de pruebas integrado que facilita la escritura y ejecución de pruebas. Comprender cómo usar las pruebas es crucial a medida que aprendes Zig, especialmente porque muchos ejemplos en la documentación de Zig se proporcionan como pruebas.
Creación de una prueba simple que pasa
Creemos un archivo de prueba básico:
- Crea un nuevo archivo llamado
test_pass.zig - Agrega el siguiente código:
const std = @import("std");
const expect = std.testing.expect;
test "always succeeds" {
try expect(true);
}
Este código importa el módulo de prueba, luego define una prueba llamada "always succeeds" que espera que true sea verdadero (lo cual siempre lo es).
Para ejecutar esta prueba:
zig test test_pass.zig
Deberías ver una salida similar a:
All 1 tests passed.
Creación de una prueba que falla
Ahora, creemos una prueba que falle para comprender cómo Zig maneja los fallos de prueba:
- Crea un archivo llamado
test_fail.zig - Agrega el siguiente código:
const std = @import("std");
const expect = std.testing.expect;
test "always fails" {
try expect(false);
}
Esta prueba espera que false sea verdadero, lo cual obviamente falla.
Cuando ejecutas:
zig test test_fail.zig
Verás una salida de error como:
Test [1/1] test.always fails... FAIL (TestUnexpectedResult)
/usr/lib/zig/std/testing.zig:515:14: 0x2241ef in expect (test)
if (!ok) return error.TestUnexpectedResult;
^
[...]/test_fail:5:5: 0x224305 in test.always fails (test)
try expect(false);
^
0 passed; 0 skipped; 1 failed.
Comprensión del manejo de errores en las pruebas
La palabra clave try es crucial en las pruebas de Zig. Intenta ejecutar una función que puede devolver un error. Si se devuelve un error, propaga ese error a la persona que llama.
Intenta ejecutar la misma prueba sin la palabra clave try:
test "will not compile correctly" {
expect(false);
}
Obtendrás un error del compilador porque no estás manejando el error potencial que expect() podría devolver.
Parte 4: Conceptos básicos de Zig para principiantes
Variables y constantes
En Zig, defines variables y constantes de la siguiente manera:
const std = @import("std");
pub fn main() void {
// Constant (cannot be changed)
const fixed_value = 42;
// Variable (can be changed)
var changeable_value = 10;
changeable_value = 20; // This is allowed
// You can specify types explicitly
const explicit_integer: i32 = 1234;
var explicit_float: f64 = 3.14159;
std.debug.print("Fixed: {d}, Changeable: {d}\\\\n",
.{fixed_value, changeable_value});
}
Tipos de datos básicos
Zig tiene varios tipos de datos integrados:
const std = @import("std");
pub fn main() void {
// Integers
const i: i32 = -42; // Signed 32-bit integer
const u: u32 = 42; // Unsigned 32-bit integer
// Floats
const f: f32 = 3.14; // 32-bit float
const d: f64 = 2.71828; // 64-bit float
// Boolean
const b: bool = true;
// Characters and strings
const c: u8 = 'A'; // Character (as integer)
const s: []const u8 = "Hello, Zig!"; // String (a slice of u8)
// Arrays with fixed size known at compile time
const arr = [5]u8{1, 2, 3, 4, 5};
std.debug.print("Integer: {d}, Float: {d}\\\\n", .{i, f});
std.debug.print("String: {s}\\\\n", .{s});
}
Funciones
Las funciones en Zig se definen usando la palabra clave fn:
const std = @import("std");
// Basic function with parameters and return value
fn add(a: i32, b: i32) i32 {
return a + b;
}
// Function that may return an error
fn divide(a: f32, b: f32) !f32 {
if (b == 0) {
return error.DivisionByZero;
}
return a / b;
}
pub fn main() void {
// Call a simple function
const sum = add(5, 3);
std.debug.print("5 + 3 = {d}\\\\n", .{sum});
// Call a function that may return an error
if (divide(10, 2)) |result| {
std.debug.print("10 / 2 = {d}\\\\n", .{result});
} else |err| {
std.debug.print("Error: {}\\\\n", .{err});
}
// Another way to handle errors
const division_result = divide(10, 0) catch |err| {
std.debug.print("Division failed: {}\\\\n", .{err});
0; // Default value in case of error
};
std.debug.print("Result (or default): {d}\\\\n", .{division_result});
}
Conclusión
Este tutorial ha cubierto los aspectos esenciales para comenzar con Zig: la instalación en diferentes sistemas operativos, la creación y ejecución de tu primer programa y el trabajo con el marco de pruebas de Zig. También hemos presentado algunos conceptos fundamentales como variables, tipos de datos y funciones.
Zig es un lenguaje poderoso que ofrece control de bajo nivel al tiempo que enfatiza la seguridad, la claridad y la mantenibilidad. Su enfoque para el manejo de errores y la gestión de la memoria lo convierte en una alternativa interesante a lenguajes como C, C++ y Rust.
Para continuar tu viaje con Zig, considera:
- Explorar la documentación oficial de Zig
- Unirte a la comunidad de Zig en Discord o al foro Ziggit
- Instalar el servidor de lenguaje Zig para una mejor integración del IDE
- Intentar construir pequeños proyectos para obtener experiencia práctica
Recuerda que Zig todavía está evolucionando, por lo que algunas características pueden cambiar a medida que el lenguaje madura hacia la versión 1.0. ¡Feliz codificación!
