---
title: "expected ';' — Como Resolver em Zig"
url: "https://ziglang.com.br/erros/expected-como-resolver-em-zig/"
markdown_url: "https://ziglang.com.br/erros/expected-como-resolver-em-zig.MD"
description: "Entenda o erro 'expected semicolon' em Zig. Saiba onde o ponto e vírgula é obrigatório, por que ele é necessário e como corrigir este erro."
date: "2026-02-21"
author: "Zig Brasil"
---

# expected ';' — Como Resolver em Zig

Entenda o erro 'expected semicolon' em Zig. Saiba onde o ponto e vírgula é obrigatório, por que ele é necessário e como corrigir este erro.


# expected ';' — Como Resolver em Zig

## O Que Este Erro Significa

O erro `expected ';'` indica que o compilador Zig encontrou o fim de uma declaração ou expressão, mas não encontrou o ponto e vírgula (`;`) que deveria terminá-la. Em Zig, a maioria das declarações e atribuições deve terminar com `;`, de forma similar a C e Rust.

A mensagem de erro aponta exatamente para o local onde o `;` era esperado.

## Causas Comuns

### 1. Esquecer o Ponto e Vírgula Após Declaração

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

### 2. Esquecer o Ponto e Vírgula Após Chamada de Função

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

pub fn main() void {
    std.debug.print("olá\n", .{})  // ERRO: expected ';'
}
```

### 3. Esquecer Após Atribuição

```zig
pub fn main() void {
    var x: u32 = 0;
    x = 42  // ERRO: expected ';'
    _ = x;
}
```

### 4. Esquecer Após return

```zig
fn soma(a: i32, b: i32) i32 {
    return a + b  // ERRO: expected ';'
}
```

### 5. Confundir com Linguagens que Não Usam ;

Programadores vindos de Python, Go, Kotlin ou Swift frequentemente esquecem o `;`:

```zig
pub fn main() void {
    const nome = "Zig"   // ERRO: em Zig, ; é obrigatório
    const versao = "0.13" // ERRO
    _ = nome;
    _ = versao;
}
```

### 6. Ponto e Vírgula Após Bloco de Controle (Desnecessário)

Curiosamente, o erro oposto também existe — colocar `;` onde não deveria:

```zig
pub fn main() void {
    const x: u32 = 5;
    if (x > 3) {
        // ...
    }; // Isso pode ou não ser um erro, dependendo do contexto
}
```

Em Zig, blocos `if`, `while`, `for` e `switch` geralmente **não** precisam de `;` quando usados como statements. Mas quando usados como expressões atribuídas, seguem as regras normais.

### 7. Usar ; Dentro de Expressão Inline

```zig
pub fn main() void {
    // Incorreto: ; no meio da expressão
    const x = if (true) 1; else 2; // ERRO
    _ = x;
}
```

## Como Corrigir

### Solução 1: Adicionar o Ponto e Vírgula

Na maioria dos casos, basta adicionar o `;`:

```zig
pub fn main() void {
    const x = 42; // Correto
    _ = x;
}
```

### Solução 2: Após Chamadas de Função

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

pub fn main() void {
    std.debug.print("olá\n", .{}); // Correto
}
```

### Solução 3: Após return

```zig
fn soma(a: i32, b: i32) i32 {
    return a + b; // Correto
}
```

### Solução 4: Entender Onde ; NÃO Deve Ir

Em Zig, você **não** coloca `;` após:

- Blocos `if`/`else` usados como statements
- Blocos `while` e `for` usados como statements
- Declarações de funções (após a `}`)
- Declarações de structs/enums (após a `}`)

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

// Sem ; após declaração de função
fn exemplo() void {
    // Sem ; após if/else como statement
    if (true) {
        std.debug.print("sim\n", .{});
    } else {
        std.debug.print("não\n", .{});
    }

    // Sem ; após for como statement
    const arr = [_]u32{ 1, 2, 3 };
    for (arr) |item| {
        _ = item;
    }
}

// Sem ; após declaração de struct
const Ponto = struct {
    x: f64,
    y: f64,
};  // MAS: ; aqui porque é uma declaração const
```

### Solução 5: Expressões if/else em Linha

Quando `if` é usado como expressão, o `;` vai no final:

```zig
pub fn main() void {
    const x: u32 = 5;
    const resultado = if (x > 3) @as(u32, 1) else @as(u32, 0); // ; no final
    _ = resultado;
}
```

## Regra Geral

Em Zig, coloque `;` após:

1. **Declarações `const` e `var`**: `const x = 5;`
2. **Atribuições**: `x = 10;`
3. **Chamadas de função como statement**: `foo();`
4. **`return`**: `return valor;`
5. **`break` e `continue`**: `break;`, `continue;`
6. **`defer` e `errdefer`**: `defer allocator.free(ptr);`
7. **`_ = expressão`**: `_ = resultado;`

Não coloque `;` após:

1. **Fechamento de bloco `}`** (quando é bloco de controle)
2. **Declarações de função** (após o `}`)
3. **Entre `if` e `else`**

## Dicas

1. **Configure seu editor** — O ZLS (Zig Language Server) mostra erros de `;` em tempo real.
2. **Zig format** — Execute `zig fmt` no seu código. Embora não adicione `;` faltantes, o formatador ajuda a manter a consistência.
3. **Leia a linha indicada** — O compilador aponta a linha exata onde o `;` era esperado.

## Erros Relacionados

- [expected expression](/erros/erro-expected-expression/) — Quando uma expressão completa é esperada
- [expected '}'](/erros/erro-missing-closing-brace/) — Quando falta chave de fechamento
- [expected block expression](/erros/erro-expected-block/) — Quando um bloco é esperado

## Links Úteis

- [Documentação oficial do Zig — Grammar](https://ziglang.org/documentation/master/#Grammar)
- [Zig Language Reference — Statements](https://ziglang.org/documentation/master/#Statements)