---
title: "Try em Zig — O que é e Como Usar"
url: "https://ziglang.com.br/glossario/try-em-zig-o-que-%C3%A9-e-como-usar/"
markdown_url: "https://ziglang.com.br/glossario/try-em-zig-o-que-%C3%A9-e-como-usar.MD"
description: "Entenda o operador try em Zig: propague erros automaticamente de forma concisa e segura. O operador mais usado no tratamento de erros. Guia pt-BR."
date: "2026-02-21"
author: "Zig Brasil"
---

# Try em Zig — O que é e Como Usar

Entenda o operador try em Zig: propague erros automaticamente de forma concisa e segura. O operador mais usado no tratamento de erros. Guia pt-BR.


# Try em Zig — O que é e Como Usar

## Definição

O operador **`try`** em Zig é um atalho para propagar erros automaticamente. Quando aplicado a um [error union](/glossario/error-union/), `try` desembrulha o valor de sucesso ou **retorna imediatamente o erro** para a função chamadora. É o equivalente do operador `?` de Rust.

`try x` é açúcar sintático para: `x catch |err| return err`.

## Por que Try Importa

1. **Concisão**: Elimina boilerplate de propagação de erros — a operação mais comum.
2. **Segurança**: Impossível esquecer de tratar ou propagar um erro.
3. **Composição**: Permite encadear operações que podem falhar de forma limpa.
4. **Clareza**: Cada `try` marca explicitamente um ponto de possível falha.

## Exemplo Prático

### Uso Básico

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

fn lerArquivo(caminho: []const u8) ![]u8 {
    const allocator = std.heap.page_allocator;

    // Cada try pode falhar e propagar o erro
    const arquivo = try std.fs.cwd().openFile(caminho, .{});
    defer arquivo.close();

    const conteudo = try arquivo.readToEndAlloc(allocator, 1024 * 1024);
    return conteudo;
}

pub fn main() !void {
    const dados = try lerArquivo("exemplo.txt");
    defer std.heap.page_allocator.free(dados);

    std.debug.print("Lido: {} bytes\n", .{dados.len});
}
```

### O que Try Faz Internamente

```zig
// Estas duas formas são equivalentes:

// Com try:
const valor = try operacaoQuePoedeFalhar();

// Sem try (expandido):
const valor = operacaoQuePoedeFalhar() catch |err| return err;
```

### Encadeando Múltiplos Trys

```zig
fn processarPedido(allocator: std.mem.Allocator) !Pedido {
    const config = try carregarConfig(allocator);
    defer allocator.free(config);

    const conexao = try conectarBanco(config);
    defer conexao.close();

    const dados = try conexao.query("SELECT * FROM pedidos LIMIT 1");
    defer allocator.free(dados);

    const pedido = try Pedido.parse(dados);
    return pedido;
}
```

Se **qualquer** `try` falhar, a função retorna imediatamente com o erro, e os `defer`s já executados garantem a limpeza dos recursos.

### Try com Errdefer

```zig
fn inicializar(allocator: std.mem.Allocator) !*App {
    const app = try allocator.create(App);
    errdefer allocator.destroy(app);

    app.config = try carregarConfig();
    errdefer app.config.deinit();

    app.db = try conectarDB(app.config);
    // Se chegar aqui, tudo deu certo

    return app;
}
```

### Try em Main

```zig
// main pode retornar erro — o runtime do Zig trata
pub fn main() !void {
    try executar();
}
// Se executar() falhar, a mensagem de erro é impressa automaticamente
```

## Try vs Catch

| Aspecto | `try` | `catch` |
|---------|-------|---------|
| Propósito | Propagar erro | Tratar erro |
| Ação em erro | Retorna o erro | Executa código customizado |
| Resultado | Valor desembrulhado | Valor desembrulhado ou fallback |
| Quando usar | Não sabe lidar com o erro | Pode recuperar do erro |

```zig
// try: propaga para quem chamou
const a = try operacao();

// catch: trata localmente
const b = operacao() catch |err| {
    log.err("Falhou: {}", .{err});
    return valor_padrao;
};
```

## Armadilhas Comuns

- **Try fora de função com error union**: `try` só funciona em funções que retornam `!T`. Usar `try` em uma função `void` (sem `!`) causa erro de compilação.
- **Usar try onde catch é melhor**: Se você pode se recuperar do erro, use `catch`. `try` é para quando o erro deve subir.
- **Perda de contexto**: `try` propaga o erro "cru". Se precisa adicionar contexação (ex: "falha ao conectar em porta 8080"), use `catch` com um novo erro.
- **Muitos trys seguidos**: Se uma função tem dezenas de `try`, considere se ela está fazendo coisas demais.
- **Esquecer `!` no retorno**: `fn foo() void` não pode usar `try`. Precisa ser `fn foo() !void`.

## Comparação com Outras Linguagens

O operador `try` de Zig é semanticamente equivalente ao operador `?` de Rust, mas com diferenças importantes:

| Aspecto | Zig `try` | Rust `?` | Go `if err != nil` |
|---------|-----------|----------|-------------------|
| Sintaxe | `try expr` | `expr?` | Manual |
| Propagação | Automática | Automática | Manual |
| Conversão de erro | Não (tipo exato) | Sim (via `From`) | Não |
| Visibilidade | Explícita (prefixo) | Implícita (sufixo) | Explícita |
| Overhead | Zero (sem exceção) | Zero | Zero |

Em Go, cada operação que pode falhar exige um bloco `if err != nil { return err }` explícito. O `try` de Zig é igualmente explícito (cada ponto de falha é marcado), mas muito mais conciso.

## Boas Práticas

- **Uma operação por `try`**: Evite encadear chamadas em uma mesma expressão com `try`. `try a(try b(x))` funciona, mas dificulta rastrear qual parte falhou.
- **Identifique os pontos de falha**: Cada `try` é uma "saída de emergência" da função. Certifique-se de que os `defer` e `errdefer` cobrem todos os recursos alocados antes de cada `try`.
- **Nomeie erros no contexto certo**: Se o erro do nível baixo não é informativo o suficiente, use `catch` para transformá-lo antes de propagar.

## Termos Relacionados

- [Error Union](/glossario/error-union/) — Tipo que carrega valor ou erro
- [Catch](/glossario/catch/) — Tratamento local de erros
- [Errdefer](/glossario/errdefer/) — Limpeza condicional em caso de erro
- [Error Set](/glossario/error-set/) — Conjuntos de erros tipados
- [Defer](/glossario/defer/) — Limpeza garantida ao sair do escopo

## Tutoriais Relacionados

- [Tratamento de Erros em Zig](/tutoriais/tratamento-de-erros-em-zig/)
- [Introdução ao Zig](/tutoriais/introducao-ao-zig/)
- [Gerenciamento de Memória em Zig](/tutoriais/gerenciamento-de-memoria-zig/)