std.io em Zig — Referência e Exemplos
std.io — Entrada e Saída O módulo std.io é o ponto central para operações de entrada e saída no Zig. Ele fornece interfaces genéricas (Writer e Reader) que são …
std em portuguêsA biblioteca padrão do Zig, também chamada de Zig stdlib ou simplesmente std, reúne os módulos oficiais usados para memória, arquivos, entrada e saída, HTTP, JSON, criptografia, testes, threads e estruturas de dados. Ela acompanha o compilador: você não instala um pacote separado para usar std.mem, std.fs, std.http ou std.testing.
Esta página funciona como um mapa da stdlib em português. Se você quer resolver uma tarefa específica, comece pela tabela abaixo; se está aprendendo a linguagem, siga a rota recomendada no fim do guia.
Resposta rápida: importe a biblioteca com
const std = @import("std");e acesse o módulo necessário, comostd.mem,std.fsoustd.json. Como a API da stdlib evolui junto com o Zig, confirme exemplos na documentação correspondente à versão do seu compilador.
stdA biblioteca padrão já está disponível em qualquer arquivo Zig:
const std = @import("std");
pub fn main() !void {
const texto = "zig,stdlib,portugues";
var partes = std.mem.splitScalar(u8, texto, ',');
while (partes.next()) |parte| {
std.debug.print("{s}\n", .{parte});
}
}
Você pode criar aliases quando isso melhora a leitura, embora usar o caminho completo geralmente deixe a origem de cada API mais clara:
const std = @import("std");
const mem = std.mem;
const fs = std.fs;
Não existe um comando equivalente a npm install std ou cargo add std: a biblioteca padrão faz parte da distribuição do Zig.
| Se você precisa de… | Comece por |
|---|---|
| Comparar strings, buscar bytes, dividir slices | std.mem |
| Alocar memória de forma explícita | std.mem.Allocator e std.heap |
| Ler ou gravar arquivos e diretórios | std.fs |
| Formatar texto ou converter números | std.fmt |
| Fazer parsing ou gerar JSON | std.json |
| Criar cliente ou servidor HTTP | std.http |
| Trabalhar com TCP, endereços e streams | std.net |
| Criar listas, mapas e filas | ArrayList, HashMap e PriorityQueue |
| Escrever testes | std.testing |
| Executar processos ou ler argumentos | std.process |
| Módulo | Descrição |
|---|---|
| std.io | Visão geral do sistema de I/O |
| std.io.Writer | Interface genérica de escrita |
| std.io.Reader | Interface genérica de leitura |
| std.io Buffered | BufferedReader e BufferedWriter |
| std.io.FixedBufferStream | Stream sobre buffer fixo |
| getStdOut, getStdErr, getStdIn | Acesso aos fluxos padrão |
| Módulo | Descrição |
|---|---|
| std.fs | Visão geral do sistema de arquivos |
| std.fs.cwd() | Diretório atual e operações |
| std.fs.File | Tipo File e operações |
| std.fs.path | Utilitários de caminhos |
| std.fs.Dir | Tipo Dir e iteração |
| Módulo | Descrição |
|---|---|
| std.mem | Visão geral de operações de memória |
| std.mem.Allocator | Interface de alocador |
| std.mem.eql | Comparação e busca em memória |
| std.mem.split | Divisão e tokenização |
| std.heap | Visão geral dos alocadores |
| GeneralPurposeAllocator | Alocador de uso geral |
| ArenaAllocator | Alocador de arena |
| page_allocator | Alocador de páginas |
| FixedBufferAllocator | Alocador sobre buffer fixo |
| Módulo | Descrição |
|---|---|
| ArrayList | Lista dinâmica (vetor) |
| ArrayHashMap | HashMap com ordem de inserção |
| HashMap | Tabela hash genérica |
| StringHashMap | HashMap com chaves string |
| MultiArrayList | Struct of Arrays |
| BoundedArray | Array com tamanho limitado |
| PriorityQueue | Fila de prioridade (heap) |
| SegmentedList | Lista segmentada |
| LinkedList | Listas ligadas |
| Módulo | Descrição |
|---|---|
| std.fmt | Visão geral de formatação |
| Sintaxe de Format | Strings de formatação |
| parseInt, parseFloat | Conversão de strings para números |
| std.json | Visão geral de JSON |
| JSON Parsing | Análise de JSON |
| JSON Stringify | Serialização JSON |
| std.Uri | Análise de URIs |
| std.base64 | Codificação Base64 |
| Módulo | Descrição |
|---|---|
| std.net | Visão geral de rede |
| std.net.Stream | Socket Stream |
| std.net.Address | Tipo Address |
| std.http | Visão geral HTTP |
| HTTP Client | Cliente HTTP |
| HTTP Server | Servidor HTTP |
| Módulo | Descrição |
|---|---|
| std.Thread | Threads nativas |
| Thread.Mutex | Mutex e sincronização |
| Thread.Pool | Pool de threads |
| std.atomic | Operações atômicas |
| Event Loop | Conceitos de event loop |
| Módulo | Descrição |
|---|---|
| std.math | Visão geral de matemática |
| Funções matemáticas | Funções comuns |
| std.crypto | Visão geral de criptografia |
| Hash functions | Funções de hash |
| Crypto random | Números aleatórios criptográficos |
| std.compress | Compressão de dados |
| Módulo | Descrição |
|---|---|
| std.os | Interface com o SO |
| std.process | Processos e ambiente |
| std.time | Tempo e cronômetros |
| std.debug | Depuração e assertivas |
| std.log | Framework de logging |
| std.testing | Utilitários de teste |
| std.sort | Algoritmos de ordenação |
A biblioteca padrão do Zig segue algumas convenções importantes:
Allocator, deixando custo e ciclo de vida visíveis.!T) e se integram a try, catch e errdefer.comptime: muitas APIs recebem tipos e funções em tempo de compilação, sem exigir um sistema separado de generics.[]const u8; operações comuns ficam em std.mem, std.ascii, std.unicode e std.fmt.defer: arquivos, alocações, sockets e outras estruturas frequentemente expõem close, free ou deinit.Ainda não completamente. Zig permanece antes da versão 1.0, portanto a biblioteca padrão pode ganhar novos módulos, remover APIs antigas ou alterar assinaturas. Um exemplo copiado para uma versão diferente do compilador pode falhar mesmo quando o conceito continua correto.
Confira sua versão antes de adaptar um exemplo:
zig version
Para documentação local e experimentação, zig std inicia o navegador de documentação fornecido pelo compilador quando esse comando está disponível na sua versão. Para APIs em evolução, também consulte a documentação oficial da versão master e compare com a versão instalada.
Se você está começando, não tente memorizar todos os módulos. Uma sequência prática é:
std.mem e o guia de strings e arrays.std.mem.Allocator e o tutorial de gerenciamento de memória.ArrayList e HashMap.std.fs, std.fmt e std.json.std.testing.std em Zig?std é o namespace da biblioteca padrão oficial que acompanha o compilador Zig. O código const std = @import("std"); disponibiliza módulos como std.mem, std.fs, std.http, std.json, std.testing e std.heap.
A stdlib não precisa ser instalada pelo gerenciador de pacotes: ela já acompanha o compilador. O sistema de pacotes é usado para dependências externas do projeto, enquanto @import("std") referencia a biblioteca padrão da versão instalada.
std.mem e std.heap?std.mem concentra operações sobre memória e slices, além de definir a interface Allocator. std.heap oferece implementações concretas de alocadores, como arena, páginas e alocadores de uso geral. Em outras palavras, std.mem.Allocator define o contrato; std.heap fornece várias estratégias para cumpri-lo.
Use as páginas ligadas neste índice para consultar módulos individuais com explicações e exemplos. Para uma visão compacta, veja também o cheatsheet da biblioteca padrão essencial.
std.io — Entrada e Saída O módulo std.io é o ponto central para operações de entrada e saída no Zig. Ele fornece interfaces genéricas (Writer e Reader) que são …
getStdOut, getStdErr, getStdIn — Fluxos Padrão As funções getStdOut(), getStdErr() e getStdIn() fornecem acesso aos três fluxos padrão de I/O do processo: saída padrão, …
std.io.FixedBufferStream — Stream sobre Buffer Fixo O FixedBufferStream é um tipo que implementa as interfaces Reader e Writer sobre um buffer de tamanho fixo em memória. …
std.io.Reader — Interface de Leitura A interface Reader é o mecanismo genérico do Zig para leitura de bytes. Assim como o Writer, ela é parametrizada em tempo de …
std.io.Writer — Interface de Escrita A interface Writer do Zig é o mecanismo genérico fundamental para escrita de bytes. Qualquer tipo que implemente a função de escrita …
std.json — Parsing e Serialização JSON O módulo std.json fornece funcionalidades completas para trabalhar com JSON no Zig. Ele inclui um parser que pode desserializar …
std.json Parsing — Desserialização de JSON O sistema de parsing JSON do Zig permite converter strings JSON em valores Zig de forma segura e eficiente. Ele suporta tanto …
std.json Stringify — Serialização para JSON A serialização JSON do Zig converte valores Zig (structs, arrays, slices, optionals, enums) em strings JSON válidas. O sistema …
std.mem — Operações de Memória O módulo std.mem fornece funções fundamentais para trabalhar com memória e slices no Zig. Ele inclui operações de comparação, busca, cópia, …
std.mem.Allocator — Interface de Alocação A interface Allocator é o mecanismo central de alocação de memória em Zig. Em vez de usar uma função global como malloc, o Zig …
std.mem.eql, indexOf e Comparações As funções de comparação e busca de std.mem são essenciais para trabalhar com strings e slices em Zig. Como o Zig trata strings como …
std.mem.split e tokenize — Divisão e Tokenização As funções split e tokenize de std.mem permitem dividir slices em partes com base em delimitadores. A diferença principal …