Trabalhando com o sistema de arquivos em Rust: um guia prático

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

Rust é uma linguagem de programação de sistemas moderna que combina alto desempenho e segurança de memória. Uma das tarefas principais que todo desenvolvedor enfrenta é trabalhar com o sistema de arquivos. Neste artigo, com exemplos práticos, vamos abordar como ler e gravar arquivos, criar diretórios, tratar erros e realizar outras operações com o sistema de arquivos em Rust.

Módulos principais para trabalhar com o sistema de arquivos

Em Rust, todo o trabalho com o sistema de arquivos está concentrado na biblioteca padrão. Os principais módulos são:

\n
• std::fs — funções para trabalhar com arquivos e diretórios (leitura, gravação, criação, exclusão).
\n
• std::path — trabalho com caminhos (Path, PathBuf).
\n
• std::io — entrada e saída, incluindo as traits Read e Write.
\n

Para começar, basta importar os módulos necessários:

use std::fs;\nuse std::path::Path;\nuse std::io::prelude::*;\nuse std::fs::File;

Leitura de arquivos em Rust

A maneira mais simples de ler um arquivo inteiro de uma vez é usar a função fs::read_to_string. Ela retorna um Result<String>, o que permite tratar erros de forma conveniente.

use std::fs;\n\nfn main() {\n    let file_path = "example.txt";\n    \n    match fs::read_to_string(file_path) {\n        Ok(content) => println!("Conteúdo do arquivo:\\n{}", content),\n        Err(e) => eprintln!("Erro ao ler o arquivo: {}", e),\n    }\n}

Se precisar ler o arquivo linha por linha (por exemplo, para arquivos grandes), use BufReader:

use std::fs::File;\nuse std::io::{BufRead, BufReader};\n\nfn main() {\n    let file = File::open("example.txt").expect("Não foi possível abrir o arquivo");\n    let reader = BufReader::new(file);\n\n    for line in reader.lines() {\n        match line {\n            Ok(content) => println!("{}", content),\n            Err(e) => eprintln!("Erro ao ler a linha: {}", e),\n        }\n    }\n}

Gravação de dados em arquivos

Para gravar dados em um arquivo, use fs::write (gravação simples de string) ou File::create com gravação subsequente via write! ou writeln!.

use std::fs;\n\nfn main() {\n    let content = "Olá, mundo!\\nEsta é uma linha para gravação.";\n    fs::write("output.txt", content).expect("Erro ao gravar o arquivo");\n    println!("Arquivo gravado com sucesso");\n}

Para gravação sequencial ou anexação de dados, use OpenOptions:

use std::fs::OpenOptions;\nuse std::io::Write;\n\nfn main() {\n    let mut file = OpenOptions::new()\n        .append(true)  // anexar ao arquivo\n        .create(true)  // criar, se não existir\n        .open("log.txt")\n        .expect("Não foi possível abrir o arquivo");\n\n    writeln!(file, "Registro no log: {}", chrono::Local::now()).expect("Erro ao gravar");\n}

Trabalhando com diretórios e caminhos

Rust fornece ferramentas convenientes para criar, excluir e percorrer diretórios. Vamos ver as operações principais.

Criação e exclusão de diretórios

use std::fs;\n\nfn main() {\n    // Criar um único diretório\n    fs::create_dir("new_folder").expect("Erro ao criar diretório");\n    \n    // Criar diretórios aninhados (análogo ao mkdir -p)\n    fs::create_dir_all("parent/child/grandchild").expect("Erro ao criar diretórios aninhados");\n    \n    // Excluir um diretório vazio\n    fs::remove_dir("new_folder").expect("Erro ao excluir diretório");\n    \n    // Excluir um diretório com todo o seu conteúdo\n    fs::remove_dir_all("parent").expect("Erro ao excluir diretório com conteúdo");\n}

Percorrendo o conteúdo de um diretório

Para obter a lista de arquivos