---
title: "expected expression — Como Resolver em Zig"
url: "https://ziglang.com.br/erros/expected-expression-como-resolver-em-zig/"
markdown_url: "https://ziglang.com.br/erros/expected-expression-como-resolver-em-zig.MD"
description: "Entenda o erro 'expected expression' em Zig, que ocorre quando o compilador espera uma expressão válida mas encontra algo inesperado."
date: "2026-02-21"
author: "Zig Brasil"
---

# expected expression — Como Resolver em Zig

Entenda o erro 'expected expression' em Zig, que ocorre quando o compilador espera uma expressão válida mas encontra algo inesperado.


# expected expression — Como Resolver em Zig

## O Que Este Erro Significa

O erro `expected expression` ocorre quando o compilador Zig está analisando o código e encontra um token (palavra, símbolo ou caractere) onde deveria haver uma expressão válida. Uma expressão em Zig é qualquer trecho de código que produz um valor — como um literal (`42`), uma variável (`x`), uma chamada de função (`foo()`), ou uma operação (`a + b`).

Quando o compilador encontra algo que não pode ser interpretado como expressão no contexto atual, ele emite este erro.

## Causas Comuns

### 1. Vírgula Extra ou Faltante

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

pub fn main() void {
    std.debug.print("{} {}\n", .{1, 2,}); // Geralmente OK com trailing comma
    std.debug.print("{}\n", .{,}); // ERRO: expected expression, encontrou ','
}
```

### 2. Parêntese ou Chave no Lugar Errado

```zig
pub fn main() void {
    const x = (+ 5); // ERRO: expected expression após '('
}
```

### 3. Operador Sem Operando

```zig
pub fn main() void {
    const x = 5 + ; // ERRO: expected expression após '+'
    _ = x;
}
```

### 4. Usar Palavras-Chave Como Expressão

```zig
pub fn main() void {
    const x = if; // ERRO: 'if' precisa de condição e corpo
    _ = x;
}
```

### 5. Bloco Vazio Onde Expressão é Esperada

```zig
pub fn main() void {
    const x = {}; // ERRO ou tipo void inesperado
    _ = x;
}
```

### 6. Sintaxe de Struct Literal Incorreta

```zig
const Ponto = struct { x: f64, y: f64 };

pub fn main() void {
    const p = Ponto{ x = 1.0, y = 2.0 }; // ERRO: use '.' antes do nome do campo
    _ = p;
}
```

### 7. Switch Sem Expressão nos Braços

```zig
fn classificar(n: i32) []const u8 {
    return switch (n) {
        0 => , // ERRO: expected expression após '=>'
        else => "outro",
    };
}
```

### 8. Array Literal com Sintaxe Incorreta

```zig
pub fn main() void {
    const arr = [3]u32{1, 2}; // ERRO: tamanho incompatível ou sintaxe incorreta
    _ = arr;
}
```

## Como Corrigir

### Solução 1: Corrigir Operadores Incompletos

Certifique-se de que cada operador tem seus operandos:

```zig
pub fn main() void {
    const x = 5 + 3; // Correto: operador '+' com dois operandos
    _ = x;
}
```

### Solução 2: Usar Sintaxe Correta de Struct Literal

Use ponto (`.`) antes do nome de cada campo:

```zig
const Ponto = struct { x: f64, y: f64 };

pub fn main() void {
    const p = Ponto{ .x = 1.0, .y = 2.0 }; // Correto: '.x' e '.y'
    _ = p;
}
```

### Solução 3: Completar Expressões em Switch

Cada braço do switch precisa de uma expressão válida:

```zig
fn classificar(n: i32) []const u8 {
    return switch (n) {
        0 => "zero",      // Correto
        1 => "um",        // Correto
        else => "outro",  // Correto
    };
}
```

### Solução 4: Usar if Como Expressão Corretamente

Em Zig, `if` pode ser usado como expressão, mas precisa da sintaxe completa:

```zig
pub fn main() void {
    const valor: i32 = 10;
    const x = if (valor > 5) @as(i32, 1) else @as(i32, 0);
    _ = x;
}
```

### Solução 5: Corrigir Array Literals

```zig
pub fn main() void {
    const arr = [_]u32{ 1, 2, 3 }; // Correto: use [_] para inferir tamanho
    _ = arr;
}
```

### Solução 6: Verificar Chamadas de Função

Certifique-se de que os argumentos são expressões válidas:

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

pub fn main() void {
    const valor: u32 = 42;
    std.debug.print("valor: {}\n", .{valor}); // Cada argumento é uma expressão válida
}
```

## Dicas de Diagnóstico

O compilador Zig geralmente indica a posição exata onde a expressão era esperada. Preste atenção na coluna indicada pelo `^` na mensagem de erro:

```
src/main.zig:5:20: error: expected expression
    const x = 5 + ;
                   ^
```

O `^` aponta exatamente onde o compilador esperava encontrar a expressão.

## Padrões Corretos de Expressão em Zig

Para referência, aqui estão os tipos válidos de expressão:

- **Literais**: `42`, `3.14`, `"texto"`, `'a'`, `true`, `null`
- **Variáveis**: `x`, `nome`, `std`
- **Chamadas de função**: `foo()`, `std.debug.print(...)`
- **Operações**: `a + b`, `!flag`, `-x`
- **Blocos com valor**: `blk: { break :blk valor; }`
- **If expressão**: `if (cond) a else b`
- **Switch expressão**: `switch (x) { ... }`
- **Struct/Array literal**: `.{ .campo = valor }`, `[_]u32{ 1, 2 }`

## Erros Relacionados

- [expected ';'](/erros/erro-missing-semicolon/) — Quando falta ponto e vírgula
- [expected '}'](/erros/erro-missing-closing-brace/) — Quando falta chave de fechamento
- [expected block expression](/erros/erro-expected-block/) — Quando um bloco é esperado
- [invalid character in source](/erros/erro-invalid-character/) — Caractere inválido no código

## Links Úteis

- [Documentação oficial do Zig — Expressões](https://ziglang.org/documentation/master/#Expressions)
- [Zig Language Reference — Operators](https://ziglang.org/documentation/master/#Operators)