Zig é uma linguagem de programação moderna e de propósito geral projetada para ser robusta, otimizada e de fácil manutenção. Com foco na simplicidade e clareza, Zig oferece controle de baixo nível enquanto evita fluxos de controle ocultos e alocações. Este tutorial o guiará pelo processo de instalação, criação do seu primeiro programa Zig e execução de testes. Ao final, você terá uma base sólida para explorar essa poderosa linguagem ainda mais.
Enquanto exploramos ferramentas poderosas para desenvolvedores, vale a pena mencionar o Apidog – a alternativa definitiva ao Postman para desenvolvimento e teste de APIs. O Apidog combina documentação de API, design, simulação, teste e depuração em uma única plataforma eficiente.
Com sua interface intuitiva, recursos de colaboração e integração perfeita de controle de versão, o Apidog melhora drasticamente a eficiência do fluxo de trabalho para desenvolvedores que trabalham com APIs. Seu conjunto abrangente de recursos inclui testes automatizados, gerenciamento de ambiente, encadeamento de solicitações e validação inteligente de respostas, tornando-o uma ferramenta essencial para equipes de desenvolvimento modernas.
Antes de mergulhar na programação em Zig, considere adicionar o Apidog ao seu kit de ferramentas de desenvolvedor para aumentar sua produtividade geral ao trabalhar com APIs e serviços web.
Parte 1: Instalando Zig
Antes de começar a programar em Zig, você precisa instalar o compilador e as ferramentas. O processo de instalação varia dependendo do seu sistema operacional.
Instalando no Linux
Você tem duas opções principais para instalar Zig no Linux:
Opção 1: Usando o gerenciador de pacotes da sua distribuição
A maioria das principais distribuições Linux empacota a versão mais recente do Zig. Essa é frequentemente a abordagem mais fácil:
# Para Debian/Ubuntu
sudo apt install zig
# Para Fedora
sudo dnf install zig
# Para Arch Linux
sudo pacman -S zig
Opção 2: Instalando manualmente
Se sua distribuição não tiver Zig ou se você precisar de uma versão específica:
Baixe uma versão pré-compilada do Zig a partir do site oficial que corresponda à sua arquitetura de CPU
Para verificar sua arquitetura, use:
uname -m
Extraia o arquivo usando tar:
tar xf zig-linux-x86_64-0.13.0.tar.xz
Adicione o binário do Zig ao seu PATH:
echo 'export PATH="$HOME/zig-linux-x86_64-0.13.0:$PATH"' >> ~/.bashrc
Aplica as alterações:
source ~/.bashrc
Instalando no Windows
Usuários do Windows têm várias opções:
Opção 1: Usando gerenciadores de pacotes
# Usando Chocolatey
choco install zig
# Usando Winget
winget install zig.zig
# Usando Scoop
scoop install zig
Opção 2: Instalação manual
Baixe uma versão pré-compilada do Zig para Windows que corresponda à sua arquitetura de CPU (a maioria dos sistemas Windows usa x86_64/AMD64)
Verifique sua arquitetura com:
$Env:PROCESSOR_ARCHITECTURE
Extraia o arquivo ZIP
Adicione Zig ao seu PATH:
Para o Usuário Atual:
[Environment]::SetEnvironmentVariable(
"Path",
[Environment]::GetEnvironmentVariable("Path", "User") + ";C:\\\\caminho\\\\para\\\\zig-windows-x86_64",
"User"
)
Para o Sistema:
[Environment]::SetEnvironmentVariable(
"Path",
[Environment]::GetEnvironmentVariable("Path", "Machine") + ";C:\\\\caminho\\\\para\\\\zig-windows-x86_64",
"Machine"
)
Feche e reabra seu terminal
Instalando no macOS
A maneira mais simples de instalar o Zig no macOS é usando o Homebrew:
brew install zig
Verificando Sua Instalação
Após a instalação, verifique se o Zig está instalado corretamente executando:
zig version
Você deve ver uma saída como:
0.13.0
Parte 2: Olá, Mundo! em Zig
Agora que o Zig está instalado, vamos criar seu primeiro programa Zig: o tradicional exemplo "Olá, Mundo!".
Criando o Arquivo do Programa
- Crie um novo arquivo chamado
main.zig - Abra-o no seu editor de texto preferido
- Adicione o seguinte código:
const std = @import("std");
pub fn main() void {
std.debug.print("Olá, {s}!\\\\n", .{"Mundo"});
}
Vamos analisar o que este código faz:
const std = @import("std");importa a biblioteca padrão do Zigpub fn main() void {declara a função principal que atua como ponto de entrada do seu programastd.debug.print("Olá, {s}!\\\\n", .{"Mundo"});imprime "Olá, Mundo!" no fluxo de erro padrão (stderr)- O
{s}é um especificador de formato para strings, e.{"Mundo"}é como Zig passa argumentos para especificadores de formato
Executando o Programa
Para compilar e executar seu programa, use o seguinte comando:
zig run main.zig
Isso compila seu código e o executa imediatamente. Você deve ver a saída:
Olá, Mundo!
Nota Importante sobre Codificação de Arquivo
O Zig exige codificação UTF-8 para arquivos fonte. Se você encontrar um erro como bytes inválidos, seu arquivo pode ter uma codificação diferente. Para corrigir isso:
zig fmt main.zig
Isso re-encodificará seu arquivo como UTF-8. Em seguida, abra o arquivo novamente no seu editor.
Parte 3: Executando Testes no Zig
O Zig possui um framework de teste embutido que facilita a escrita e a execução de testes. Compreender como usar testes é crucial enquanto você aprende Zig, especialmente já que muitos exemplos na documentação do Zig são fornecidos como testes.
Criando um Teste Simples que Passa
Vamos criar um arquivo de teste básico:
- Crie um novo arquivo chamado
test_pass.zig - Adicione o seguinte código:
const std = @import("std");
const expect = std.testing.expect;
test "sempre passa" {
try expect(true);
}
Este código importa o módulo de teste e, em seguida, define um teste chamado "sempre passa" que espera que true seja verdadeiro (o que sempre é).
Para executar este teste:
zig test test_pass.zig
Você deve ver uma saída semelhante a:
Todos os 1 testes passaram.
Criando um Teste que Falha
Agora, vamos criar um teste que falha para entender como o Zig lida com falhas de teste:
- Crie um arquivo chamado
test_fail.zig - Adicione o seguinte código:
const std = @import("std");
const expect = std.testing.expect;
test "sempre falha" {
try expect(false);
}
Este teste espera que false seja verdadeiro, o que obviamente falha.
Quando você executar:
zig test test_fail.zig
Você verá uma saída de erro como:
Teste [1/1] test.sempre falha... FALHA (ResultadoInesperadoTeste)
/usr/lib/zig/std/testing.zig:515:14: 0x2241ef em expect (teste)
if (!ok) return error.TestUnexpectedResult;
^
[...]/test_fail:5:5: 0x224305 em test.sempre falha (teste)
try expect(false);
^
0 aprovados; 0 pulados; 1 falhou.
Compreendendo o Tratamento de Erros nos Testes
A palavra-chave try é crucial nos testes em Zig. Ela tenta executar uma função que pode retornar um erro. Se um erro for retornado, ele propaga esse erro para o chamador.
Tente executar o mesmo teste sem a palavra-chave try:
test "não irá compilar corretamente" {
expect(false);
}
Você receberá um erro de compilador porque não está lidando com o erro potencial que expect() pode retornar.
Parte 4: Fundamentos do Zig para Iniciantes
Variáveis e Constantes
No Zig, você define variáveis e constantes da seguinte forma:
const std = @import("std");
pub fn main() void {
// Constante (não pode ser alterada)
const valor_fixo = 42;
// Variável (pode ser alterada)
var valor_mutável = 10;
valor_mutável = 20; // Isso é permitido
// Você pode especificar tipos explicitamente
const inteiro_explicito: i32 = 1234;
var float_explicito: f64 = 3.14159;
std.debug.print("Fixo: {d}, Mutável: {d}\\\\n",
.{valor_fixo, valor_mutável});
}
Tipos de Dados Básicos
O Zig possui vários tipos de dados embutidos:
const std = @import("std");
pub fn main() void {
// Inteiros
const i: i32 = -42; // Inteiro assinado de 32 bits
const u: u32 = 42; // Inteiro não assinado de 32 bits
// Flutuantes
const f: f32 = 3.14; // Flutuante de 32 bits
const d: f64 = 2.71828; // Flutuante de 64 bits
// Booleano
const b: bool = true;
// Caracteres e strings
const c: u8 = 'A'; // Caractere (como inteiro)
const s: []const u8 = "Olá, Zig!"; // String (uma fatia de u8)
// Arrays com tamanho fixo conhecido em tempo de compilação
const arr = [5]u8{1, 2, 3, 4, 5};
std.debug.print("Inteiro: {d}, Flutuante: {d}\\\\n", .{i, f});
std.debug.print("String: {s}\\\\n", .{s});
}
Funções
As funções em Zig são definidas usando a palavra-chave fn:
const std = @import("std");
// Função básica com parâmetros e valor de retorno
fn adicionar(a: i32, b: i32) i32 {
return a + b;
}
// Função que pode retornar um erro
fn dividir(a: f32, b: f32) !f32 {
if (b == 0) {
return error.DivisãoPorZero;
}
return a / b;
}
pub fn main() void {
// Chama uma função simples
const soma = adicionar(5, 3);
std.debug.print("5 + 3 = {d}\\\\n", .{soma});
// Chama uma função que pode retornar um erro
if (dividir(10, 2)) |resultado| {
std.debug.print("10 / 2 = {d}\\\\n", .{resultado});
} else |err| {
std.debug.print("Erro: {}\\\\n", .{err});
}
// Outra maneira de lidar com erros
const resultado_divisao = dividir(10, 0) catch |err| {
std.debug.print("Divisão falhou: {}\\\\n", .{err});
0; // Valor padrão em caso de erro
};
std.debug.print("Resultado (ou padrão): {d}\\\\n", .{resultado_divisao});
}
Conclusão
Este tutorial abordou os fundamentos de como começar com Zig - instalação em diferentes sistemas operacionais, criação e execução do seu primeiro programa e trabalho com o framework de testes do Zig. Também introduzimos alguns conceitos fundamentais, como variáveis, tipos de dados e funções.
O Zig é uma linguagem poderosa que oferece controle de baixo nível, enfatizando segurança, clareza e manutenabilidade. Sua abordagem ao tratamento de erros e gerenciamento de memória a torna uma alternativa interessante a linguagens como C, C++ e Rust.
Para continuar sua jornada com Zig, considere:
- Explorar a documentação oficial do Zig
- Juntar-se à comunidade Zig no Discord ou no fórum Ziggit
- Instalar o Servidor de Linguagem Zig para melhor integração com IDEs
- Tentar construir pequenos projetos para ganhar experiência prática
Lembre-se de que o Zig ainda está evoluindo, então alguns recursos podem mudar conforme a linguagem amadurece em direção à versão 1.0. Boa codificação!