Aula 09 - Tratamento de Erros ⚠️

Objetivo

Objetivo: Compreender a filosofia do Rust para lidar com falhas, diferenciando erros fatais de erros recuperáveis, e dominar o uso do tipo Result para um código robusto.

1. Erros Irrecuperáveis com `panic!` 💥

Um panic! indica que algo aconteceu que o programa não sabe como lidar. Quando ocorre, o programa imprime uma mensagem, limpa a memória (unwinding) e encerra.

fn main() {
    // panic!("Algo deu muito errado!");

    let v = vec![1, 2, 3];
    v[99]; // Erro de índice causará um panic automático!
}

2. Erros Recuperáveis com `Result<T, E>` 🛡️

A maioria dos erros não são fatais. Para esses, o Rust usa o Enum Result.

enum Result<T, E> {
    Ok(T),  // Sucesso, contém o valor T
    Err(E), // Erro, contém o erro E
}

Exemplo Prático: Abrindo um Arquivo

use std::fs::File;

fn main() {
    let f = File::open("hello.txt");

    let arquivo = match f {
        Ok(file) => file,
        Err(error) => panic!("Problema ao abrir o arquivo: {:?}", error),
    };
}

3. Atalhos: `unwrap` e `expect` ⚡

Se você tem certeza que a operação terá sucesso ou quer que o programa dê panic em caso de erro, pode usar esses atalhos:

unwrap(): Retorna o valor interno se for Ok, caso contrário, chama panic!.
expect("mensagem"): Similar ao unwrap, mas permite definir a mensagem de erro.

let f = File::open("hello.txt").expect("Arquivo hello.txt deve existir!");

4. Propagação de Erros e o Operador `?` 🚀

Em vez de tratar o erro na própria função, você pode "passá-lo adiante" para quem chamou a função usando o operador ?.

use std::fs::File;
use std::io::{self, Read};

fn ler_usuario_de_arquivo() -> Result<String, io::Error> {
    let mut s = String::new();
    File::open("hello.txt")?.read_to_string(&mut s)?; // O ? retorna o erro automaticamente se ocorrer
    Ok(s)
}

5. Visualização: Fluxo do Operador `?` 🔄

graph LR
    A["Chamada da Função"] --> B{Deu erro?}
    B -->|Não| C["Continua Execução"]
    B -->|Sim| D["Retorna Err(e) Imediatamente"]
    style B fill:#f96,stroke:#333

6. Mini-Projeto: Leitor de Configurações ⚙️

Desenvolva uma ferramenta que: 1. Tente ler um arquivo de configuração (ex: config.txt). 2. Se o arquivo não existir, crie um arquivo padrão com valores iniciais. 3. Use Result e o operador ? para gerenciar as falhas de leitura/escrita. 4. Trate erros de permissão ou arquivo corrompido de forma amigável para o usuário, sem travar o programa.

7. Exercício de Fixação 🧠

Quando devemos usar panic! em vez de retornar um Result?
O que o operador ? faz por baixo dos panos?
Por que o uso excessivo de unwrap() é considerado uma má prática em código de produção?

Próxima Aula: Vamos aumentar a reutilização de código com Generics e Traits! 🧬

Aula 09 - Tratamento de Erros ⚠️

1. Erros Irrecuperáveis com panic! 💥

2. Erros Recuperáveis com Result<T, E> 🛡️