Trabalhando com o sistema de arquivos em Rust: guia completo

Introdução ao Trabalho com o Sistema de Arquivos em Rust

Rust é uma linguagem de programação de sistemas moderna que oferece ferramentas poderosas e seguras para interagir com o sistema de arquivos. Diferente de muitas outras linguagens, Rust garante segurança de memória e de threads, o que é especialmente importante para operações de entrada/saída. Neste artigo, examinaremos detalhadamente como criar, ler, escrever arquivos e diretórios, gerenciar caminhos e tratar erros usando a biblioteca padrão std::fs e std::path.

O material será útil tanto para iniciantes que estão conhecendo Rust quanto para desenvolvedores experientes que desejam atualizar seus conhecimentos. Todos os exemplos de código estão prontos para execução e acompanhados de comentários.

Módulos Principais e Imports

Dois módulos chave são usados para trabalhar com o sistema de arquivos em Rust:

• std::fs — fornece funções para operações com arquivos e pastas (ler, escrever, deletar, copiar, etc.).
• std::path — contém os tipos Path e PathBuf para trabalhar com caminhos.

Para a maioria das tarefas, basta adicionar os seguintes imports:

use std::fs;use std::path::Path;use std::io::prelude::*; // para trabalhar com streams

Trabalhando com Arquivos: Leitura e Escrita

Lendo o Conteúdo de um Arquivo

A maneira mais simples de ler um arquivo inteiro em uma string é usar a função fs::read_to_string. Ela retorna um Result<String>, então você precisa tratar um possível erro.

use std::fs;

fn read_file(path: &str) -> Result<String, std::io::Error> {    let content = fs::read_to_string(path)?;    Ok(content)}

fn main() {    match read_file("example.txt") {        Ok(text) => println!("Conteúdo do arquivo:{}", text),        Err(e) => eprintln!("Erro de leitura: {}", e),    }}

Se você precisar ler um arquivo como dados binários, use fs::read, que retorna Vec<u8>.

Escrevendo em um Arquivo

Para escrever uma string em um arquivo, use fs::write. Ele criará o arquivo se não existir ou sobrescreverá um existente.

use std::fs;

fn write_file(path: &str, content: &str) -> Result<(), std::io::Error> {    fs::write(path, content)?;    println!("Arquivo escrito com sucesso");    Ok(())}

fn main() {    let data = "Olá, Rust!Segunda linha.";    if let Err(e) = write_file("output.txt", data) {        eprintln!("Erro de escrita: {}", e);    }}

Para anexar ao final de um arquivo ou ter um controle mais refinado, use OpenOptions:

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

fn append_to_file(path: &str, line: &str) -> Result<(), std::io::Error> {    let mut file = OpenOptions::new()        .append(true)        .create(true)        .open(path)?;    writeln!(file, "{}", line)?;    Ok(())}

Trabalhando com Diretórios

Criando e Deletando Pastas

Para criar um diretório, use fs::create_dir (pasta única) ou fs::create_dir_all (recursivamente, como mkdir -p).

use std::fs;

fn main() -> Result<(), std::io::Error> {    // Criando uma única pasta    fs::create_dir("minha_pasta")?;

    // Criando pastas aninhadas recursivamente    fs::create_dir_all("dados/subdir/logs")?;

    // Deletando uma pasta vazia    fs::remove_dir("minha_pasta")?;

    // Deletando recursivamente uma pasta com todo o seu conteúdo    fs::remove_dir_all("dados")?;

    Ok(())}

Lendo o Conteúdo de um Diretório

A função fs::read_dir retorna um iterador sobre as entradas de um diretório. Cada entrada é um DirEntry, do qual você pode obter o nome, tipo e metadados.

use std::fs;

fn list_directory(path: