---
title: "unused local variable / unused const — Como Resolver em Zig"
url: "https://ziglang.com.br/erros/unused-local-variable-/-unused-const-como-resolver-em-zig/"
markdown_url: "https://ziglang.com.br/erros/unused-local-variable-/-unused-const-como-resolver-em-zig.MD"
description: "Entenda o erro 'unused local variable' e 'unused const' em Zig, por que variáveis não utilizadas são proibidas e como resolver corretamente."
date: "2026-02-21"
author: "Zig Brasil"
---

# unused local variable / unused const — Como Resolver em Zig

Entenda o erro 'unused local variable' e 'unused const' em Zig, por que variáveis não utilizadas são proibidas e como resolver corretamente.


# unused local variable / unused const — Como Resolver em Zig

## O Que Este Erro Significa

O erro `unused local variable` (ou `unused const`) aparece quando você declara uma variável ou constante no seu código, mas nunca a utiliza. Diferente de muitas outras linguagens que apenas emitem um aviso (warning), o Zig trata variáveis não utilizadas como um **erro de compilação**. Isso faz parte da filosofia do Zig de tornar os programas mais legíveis e evitar código morto.

A mensagem completa geralmente aparece assim:

```
error: unused local variable 'x'
```

ou

```
error: unused local constant 'config'
```

## Por Que Zig Proíbe Variáveis Não Utilizadas?

O Zig foi projetado com foco em clareza e correção. Variáveis não utilizadas frequentemente indicam:

1. **Código incompleto** — Você declarou a variável mas esqueceu de usá-la
2. **Refatoração incompleta** — A variável era usada antes, mas a lógica mudou
3. **Erro de lógica** — Você está usando outra variável quando deveria usar esta

Ao tornar isso um erro, o compilador força o programador a manter o código limpo.

## Causas Comuns

### 1. Variável Declarada e Nunca Usada

```zig
pub fn main() void {
    const mensagem = "Olá, Zig!"; // ERRO: unused local constant 'mensagem'
}
```

### 2. Variável de Iteração Não Utilizada

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

pub fn main() void {
    const items = [_]u32{ 1, 2, 3, 4, 5 };
    for (items) |item| { // ERRO: unused local constant 'item'
        std.debug.print("iterando\n", .{});
    }
}
```

### 3. Resultado de Função Não Utilizado

```zig
pub fn main() void {
    const resultado = calcular(); // ERRO: unused local constant 'resultado'
}

fn calcular() u32 {
    return 42;
}
```

### 4. Parâmetro de Captura Não Utilizado

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

pub fn main() void {
    const valor: ?u32 = 42;
    if (valor) |v| { // ERRO: unused local constant 'v'
        std.debug.print("tem valor\n", .{});
    }
}
```

### 5. Import Não Utilizado

```zig
const std = @import("std");
const math = @import("std").math; // ERRO: unused local constant 'math'

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

## Como Corrigir

### Solução 1: Usar a Variável

A solução mais óbvia — use a variável para o que ela foi criada:

```zig
pub fn main() void {
    const mensagem = "Olá, Zig!";
    std.debug.print("{s}\n", .{mensagem}); // Agora é usada
}
```

### Solução 2: Usar _ (Underscore) para Descartar

Se você intencionalmente não precisa do valor, atribua-o a `_`:

```zig
pub fn main() void {
    _ = calcular(); // Descarta o resultado explicitamente
}

fn calcular() u32 {
    return 42;
}
```

### Solução 3: Usar _ em Capturas de Iteração

Quando não precisa do valor de iteração:

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

pub fn main() void {
    const items = [_]u32{ 1, 2, 3, 4, 5 };
    for (items) |_| { // Underscore descarta o valor
        std.debug.print("iterando\n", .{});
    }
}
```

### Solução 4: Usar _ em Capturas de Optional/Error

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

pub fn main() void {
    const valor: ?u32 = 42;
    if (valor) |_| {
        std.debug.print("tem valor\n", .{});
    }
}
```

### Solução 5: Remover a Declaração

Se a variável realmente não é necessária, simplesmente remova-a:

```zig
const std = @import("std");
// removido: const math = @import("std").math;

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

### Solução 6: Prefixar com _ para Variáveis Futuras

Se você sabe que vai usar a variável em breve (durante desenvolvimento), pode prefixar com underscore:

```zig
pub fn main() void {
    const _config = carregarConfig(); // Compila, mas indica uso futuro
    _ = _config;
}
```

No entanto, em Zig, mesmo variáveis prefixadas com `_` precisam do `_ = _config;` se não forem usadas de outra forma.

## Padrões Comuns

### Descartando Múltiplos Retornos

Quando uma função retorna uma tupla e você não precisa de todos os valores:

```zig
fn obterCoordenadas() struct { x: f64, y: f64, z: f64 } {
    return .{ .x = 1.0, .y = 2.0, .z = 3.0 };
}

pub fn main() void {
    const coords = obterCoordenadas();
    // Use apenas o que precisa
    std.debug.print("x: {d}\n", .{coords.x});
    // coords.y e coords.z são acessados indiretamente via coords
}
```

### Em Testes

Mesmo em blocos de teste, variáveis não utilizadas são erros:

```zig
const std = @import("std");
const expect = std.testing.expect;

test "exemplo" {
    const resultado = soma(2, 3);
    try expect(resultado == 5); // resultado é utilizado aqui
}

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

## Dicas Importantes

1. **Não use `_ =` em excesso** — Se você está descartando muitas variáveis, repense seu design.
2. **Limpe imports** — Remova imports que não são mais necessários ao invés de descartá-los.
3. **IDE ajuda** — Editores com suporte a Zig (VS Code + ZLS) destacam variáveis não utilizadas antes da compilação.

## Erros Relacionados

- [error payload not used](/erros/erro-payload-not-used/) — Payload de erro capturado mas não utilizado
- [shadows declaration from outer scope](/erros/erro-shadowed-variable/) — Variável sombreia outra no escopo externo
- [undeclared identifier](/erros/erro-undeclared-identifier/) — Variável usada sem ser declarada

## Links Úteis

- [Documentação oficial do Zig — Variáveis](https://ziglang.org/documentation/master/#Variables)
- [Zig Language Reference — Identifiers](https://ziglang.org/documentation/master/#Identifiers)