Trabalhando com o sistema de arquivos em Rust: exemplos práticos e dicas

Trabalhando com o sistema de arquivos em Rust: na prática

Rust é uma linguagem de sistema moderna que dá ao desenvolvedor controle total sobre a memória, garantindo segurança. Trabalhar com o sistema de arquivos é uma das tarefas básicas que precisam ser resolvidas em praticamente qualquer projeto. Neste artigo, vamos explorar como ler e escrever arquivos, gerenciar diretórios e navegar por pastas com exemplos práticos. Todos os exemplos estão escritos em Rust e prontos para uso.

Módulos e estruturas principais

Em Rust, o módulo std::fs (file system) e std::path são responsáveis pelo trabalho com o sistema de arquivos e caminhos. Os tipos principais são:

• std::fs::File — representa um arquivo aberto.
• std::fs::read_dir — iterador sobre o conteúdo de um diretório.
• std::path::Path e std::path::PathBuf — para trabalhar com caminhos.

Importação dos módulos:

use std::fs;use std::path::Path;

Leitura completa de arquivo

A maneira mais simples de ler um arquivo de texto pequeno é usar a função fs::read_to_string. Ela retorna um Result<String>.

use std::fs;

fn main() {    let content = fs::read_to_string("example.txt")        .expect("Não foi possível ler o arquivo");    println!("Conteúdo do arquivo:{}", content);}

Se o arquivo não existir ou não houver permissão de acesso, o programa será encerrado com pânico. Em projetos reais, use match ou o operador ? para tratamento de erros.

Tratamento de erros na leitura

use std::fs;

fn read_file(path: &str) -> Result<String, std::io::Error> {    fs::read_to_string(path)}

fn main() {    match read_file("config.txt") {        Ok(data) => println!("{}", data),        Err(e) => eprintln!("Erro: {}", e),    }}

Escrita de dados em arquivo

Para escrever, usa-se fs::write (sobrescreve o arquivo) ou a criação de File com as opções OpenOptions.

Escrita simples de string

use std::fs;

fn main() {    let data = "Hello, Rust!";    fs::write("output.txt", data)        .expect("Não foi possível escrever o arquivo");    println!("Arquivo escrito com sucesso");}

Anexar ao final do arquivo

use std::fs::OpenOptions;use std::io::Write;

fn main() {    let mut file = OpenOptions::new()        .append(true)        .create(true)        .open("log.txt")        .expect("Não foi possível abrir o arquivo");

    writeln!(file, "{} - registro no log", chrono::Local::now())        .expect("Não foi possível escrever");}

Observe: OpenOptions permite configurar o modo de forma flexível — criação, sobrescrita, anexação, leitura.

Trabalhando com diretórios

Criar, excluir e navegar por pastas são tarefas comuns. Vamos vê-las.

Criação de novo diretório

use std::fs;

fn main() {    fs::create_dir("new_folder")        .expect("Não foi possível criar a pasta");    // Criação de pastas aninhadas (recursivamente)    fs::create_dir_all("parent/child/grandchild")        .expect("Não foi possível criar as pastas aninhadas");}

Exclusão de diretório

use std::fs;

fn main() {    // Exclui apenas pasta vazia    fs::remove_dir("empty_folder").ok();    // Exclusão recursiva com todo o conteúdo    fs::remove_dir_all("temp_data")        .expect("Não foi possível excluir a pasta");}

Cuidado com remove_dir_all — ele exclui permanentemente todo o conteúdo.

Navegação pelo conteúdo do diretório

Iteração sobre arquivos e pastas dentro de um diretório:

use std::fs;

fn main() {    let entries = fs::read_dir(".")        .expect("Não foi possível ler o diretório");\