---
title: "Cheatsheet: Sintaxe Básica em Zig"
url: "https://ziglang.com.br/cheatsheets/cheatsheet-sintaxe-b%C3%A1sica-em-zig/"
markdown_url: "https://ziglang.com.br/cheatsheets/cheatsheet-sintaxe-b%C3%A1sica-em-zig.MD"
description: "Referência rápida da sintaxe básica de Zig: variáveis, constantes, operadores, comentários e estrutura de um programa. Guia completo em português."
date: "2026-02-21"
author: "Zig Brasil"
---

# Cheatsheet: Sintaxe Básica em Zig

Referência rápida da sintaxe básica de Zig: variáveis, constantes, operadores, comentários e estrutura de um programa. Guia completo em português.


# Cheatsheet: Sintaxe Básica em Zig

Referência rápida para a sintaxe fundamental da linguagem Zig. Esta cheatsheet cobre tudo que você precisa para começar a escrever programas em Zig.

## Estrutura Básica de um Programa

```zig
const std = @import("std");

pub fn main() !void {
    const stdout = std.io.getStdOut().writer();
    try stdout.print("Olá, {s}!\n", .{"mundo"});
}
```

**Pontos-chave:**
- Todo programa Zig precisa de uma função `main`
- `pub fn main()` define o ponto de entrada público
- `!void` indica que a função pode retornar um erro ou `void`
- `@import` é um builtin para importar módulos

## Variáveis e Constantes

```zig
// Constantes (imutáveis) - preferidas em Zig
const x: i32 = 42;
const nome = "Zig";  // tipo inferido: *const [3:0]u8

// Variáveis (mutáveis)
var contador: u32 = 0;
contador += 1;

// Sem tipo explícito (inferência)
const pi = 3.14159;  // comptime_float
var flag = true;      // bool

// Undefined - valor não inicializado
var buffer: [100]u8 = undefined;
```

**Regras importantes:**
- Use `const` sempre que possível — o compilador exige
- `var` só quando realmente precisar mudar o valor
- Variáveis não usadas causam erro de compilação: use `_ = variavel;` para descartar

## Comentários

```zig
// Comentário de linha única

/// Comentário de documentação (doc comment)
/// Aparece na documentação gerada automaticamente
pub fn minhaFuncao() void {}

//! Comentário de módulo (top-level doc comment)
//! Descreve o propósito do arquivo/módulo
```

**Nota:** Zig não tem comentários de bloco (`/* */`). Apenas comentários de linha com `//`.

## Operadores Aritméticos

```zig
const a: i32 = 10;
const b: i32 = 3;

const soma = a + b;        // 13
const subtracao = a - b;    // 7
const multiplicacao = a * b; // 30
const divisao = @divTrunc(a, b); // 3 (divisão truncada)
const modulo = @mod(a, b);       // 1
const negacao = -a;              // -10

// Operações com overflow checked (padrão)
// Se houver overflow, é um erro de runtime detectável

// Operações com wrapping (sem verificação de overflow)
const wrap_add = a +% b;  // wrapping add
const wrap_mul = a *% b;  // wrapping multiply

// Operações saturadas
const sat_add = a +| b;   // saturating add
const sat_sub = a -| b;   // saturating subtract
```

## Operadores Bit a Bit

```zig
const x: u8 = 0b1010_1010;
const y: u8 = 0b1100_1100;

const and_result = x & y;    // AND: 0b1000_1000
const or_result = x | y;     // OR:  0b1110_1110
const xor_result = x ^ y;    // XOR: 0b0110_0110
const not_result = ~x;       // NOT: 0b0101_0101
const shl_result = x << 2;   // Shift left
const shr_result = x >> 2;   // Shift right
```

## Operadores de Comparação

```zig
const a: i32 = 5;
const b: i32 = 10;

const igual = (a == b);          // false
const diferente = (a != b);      // true
const menor = (a < b);           // true
const maior = (a > b);           // false
const menor_igual = (a <= b);    // true
const maior_igual = (a >= b);    // false
```

## Operadores Lógicos

```zig
const x = true;
const y = false;

const e_logico = x and y;    // false
const ou_logico = x or y;    // true
const negacao_logica = !x;   // false
```

## Literais Numéricos

```zig
// Inteiros
const decimal = 42;
const hexadecimal = 0xFF;
const octal = 0o77;
const binario = 0b1010_1111;

// Separadores visuais com underscore
const milhao = 1_000_000;
const hex_grande = 0xFF_FF_FF_FF;

// Ponto flutuante
const float1 = 3.14;
const float2 = 1.0e10;
const float3 = 0x1.0p10;  // hexadecimal float
```

## Strings e Caracteres

```zig
// String literal (array de bytes terminado em sentinela)
const saudacao = "Olá, mundo!";

// Caractere (u8)
const letra: u8 = 'A';

// String multilinha
const texto_longo =
    \\Esta é uma string
    \\que ocupa várias linhas
    \\sem necessidade de concatenação
;

// Sequências de escape
const nova_linha = "linha1\nlinha2";
const tab = "col1\tcol2";
const aspas = "ele disse \"olá\"";
const barra = "caminho\\arquivo";
const nulo = "texto\x00nulo";  // byte nulo
```

## Blocos e Escopo

```zig
// Blocos nomeados com valor de retorno
const resultado = blk: {
    var temp: i32 = 10;
    temp *= 2;
    break :blk temp;  // retorna 20
};

// Blocos simples para escopo
{
    var temp: i32 = 42;
    _ = temp;
    // temp não é acessível fora deste bloco
}
```

## Atribuição Composta

```zig
var x: i32 = 10;

x += 5;   // x = x + 5  → 15
x -= 3;   // x = x - 3  → 12
x *= 2;   // x = x * 2  → 24
x /= 4;   // compilador rejeita para inteiros — use @divTrunc
x %= 3;   // compilador rejeita — use @mod ou @rem

// Atribuição com bit a bit
var y: u8 = 0xFF;
y &= 0x0F;  // AND
y |= 0xF0;  // OR
y ^= 0xFF;  // XOR
y <<= 2;    // shift left
y >>= 1;    // shift right
```

## Conversão de Tipos (Casting)

```zig
const x: i32 = 42;

// Conversão segura (widening)
const y: i64 = x;  // i32 → i64 é sempre seguro

// Conversão explícita com @intCast
const z: i16 = @intCast(x);  // pode falhar se valor não couber

// @as para casting explícito
const w = @as(f64, 3.14);

// Conversão entre inteiro e float
const float_val: f32 = @floatFromInt(x);
const int_val: i32 = @intFromFloat(float_val);

// Truncamento
const grande: u16 = 1000;
const pequeno: u8 = @truncate(grande);  // trunca bits superiores
```

## Optionals

```zig
// Tipo optional: pode ser null ou um valor
var maybe_valor: ?i32 = null;
maybe_valor = 42;

// Desempacotar com if
if (maybe_valor) |valor| {
    // valor é i32, não ?i32
    std.debug.print("Valor: {}\n", .{valor});
}

// Desempacotar com orelse
const valor = maybe_valor orelse 0;  // 42 ou 0 se null

// Forçar desempacotamento (panic se null)
const forcar = maybe_valor.?;
```

## Sentinela e Null-Terminated

```zig
// Array com sentinela
const nome: [:0]const u8 = "Zig";  // terminado em null

// Verificar sentinela
const arr: [5:0]u8 = .{ 'h', 'e', 'l', 'l', 'o' };
// arr[5] == 0 (sentinela)
```

## Defer e Errdefer

```zig
pub fn exemplo() !void {
    var recurso = try abrirRecurso();
    defer recurso.fechar();  // executa ao sair do escopo

    errdefer std.debug.print("Erro ao processar!\n", .{});
    // errdefer só executa se a função retornar erro

    try processarRecurso(recurso);
}
```

## Print e Debug

```zig
const std = @import("std");

// Debug print (stderr) — mais simples
std.debug.print("Debug: x = {}\n", .{x});

// Stdout formatado
const stdout = std.io.getStdOut().writer();
try stdout.print("Valor: {d}\n", .{42});
try stdout.print("String: {s}\n", .{"olá"});
try stdout.print("Hex: 0x{x}\n", .{255});
try stdout.print("Binário: {b}\n", .{42});

// Log
std.log.info("Informação: {}", .{valor});
std.log.warn("Aviso: {}", .{msg});
std.log.err("Erro: {}", .{err});
```

## Dicas Rápidas

| Conceito | Sintaxe |
|----------|---------|
| Importar módulo | `const std = @import("std");` |
| Constante | `const x = 42;` |
| Variável | `var x: i32 = 0;` |
| Descartar valor | `_ = funcao();` |
| String literal | `"texto"` |
| Caractere | `'A'` |
| Null | `null` (só para optionals) |
| Undefined | `undefined` |
| Comentário | `// comentário` |
| Doc comment | `/// documentação` |

## Veja Também

- [Tipos de Dados](/cheatsheets/tipos-dados/) — Referência completa de tipos
- [Controle de Fluxo](/cheatsheets/controle-fluxo/) — if, while, for, switch
- [Funções](/cheatsheets/funcoes/) — Declaração e uso de funções
- [Tutoriais para Iniciantes](/tutoriais/zig-para-iniciantes/) — Aprenda Zig do zero
- [FAQ para Iniciantes](/faq/faq-iniciantes/) — Perguntas comuns de quem está começando