Trabalhando com o sistema de arquivos em Rust: guia completo para iniciantes

Introdução ao trabalho com o sistema de arquivos em Rust

Rust é uma linguagem de programação de sistemas moderna que dá enorme ênfase à segurança, desempenho e controle de memória. Trabalhar com o sistema de arquivos é uma das tarefas fundamentais que todo desenvolvedor enfrenta. Neste artigo, abordaremos detalhadamente como ler e escrever arquivos, criar diretórios, tratar erros e usar a biblioteca padrão std::fs para interagir eficientemente com o sistema de arquivos.

Começaremos com o básico e gradualmente passaremos para cenários mais complexos. Todos os exemplos de código estão escritos em Rust e prontos para execução. Se você está começando a aprender Rust, este artigo será um excelente ponto de partida para dominar a entrada e saída (I/O) nesta linguagem.

Módulos e tipos principais para trabalhar com o sistema de arquivos

Em Rust, toda a funcionalidade para trabalhar com arquivos e diretórios está concentrada no módulo std::fs. Além disso, os tipos Path e PathBuf do módulo std::path desempenham um papel importante, representando caminhos para arquivos e diretórios.

Tipos Path e PathBuf

Path é uma fatia (slice) para trabalhar com caminhos sem possuir os dados. PathBuf é a versão proprietária, que pode ser modificada. Eles fornecem métodos convenientes para manipulação de caminhos.

use std::path::Path;use std::path::PathBuf;

fn main() {    // Criando PathBuf    let mut path = PathBuf::from("/tmp");    path.push("example.txt");    println!("Caminho: {}", path.display());

    // Convertendo para Path    let path_ref: &Path = path.as_path();    println!("Diretório pai: {:?}", path_ref.parent());}

Módulo std::fs

O módulo std::fs contém as principais funções para trabalhar com o sistema de arquivos. Aqui estão as mais usadas:

• read_to_string — leitura de arquivo para uma string
• write — escrita de dados em um arquivo
• create_dir e create_dir_all — criação de diretórios
• remove_file e remove_dir — exclusão de arquivos e diretórios
• metadata — obtenção de informações sobre um arquivo
• copy e rename — cópia e renomeação

Leitura e escrita de arquivos em Rust

A maneira mais simples de ler ou escrever um arquivo é usar funções wrapper que realizam todo o trabalho em uma única chamada. Elas são adequadas para arquivos pequenos que cabem inteiramente na memória.

Lendo um arquivo inteiro

use std::fs;

fn main() -> Result<(), std::io::Error> {    let content = fs::read_to_string("hello.txt")?;    println!("Conteúdo do arquivo:{}", content);    Ok(())}

A função read_to_string retorna um Result<String>. Se o arquivo não existir ou não houver permissão de leitura, um erro será retornado. Observe o operador ? — ele propaga automaticamente o erro para cima.

Escrevendo em um arquivo

use std::fs;

fn main() -> Result<(), std::io::Error> {    let data = "Olá, Rust!";    fs::write("output.txt", data)?;    println!("Arquivo escrito com sucesso");    Ok(())}

A função write sobrescreve o arquivo se ele existir ou cria um novo. Para adicionar dados ao final do arquivo, use OpenOptions.

Trabalhando com arquivos binários

Para ler e escrever dados binários, use read e write com um vetor de bytes:

use std::fs;

fn main() -> Result<(), std::io::Error> {    // Escrita de dados binários    let bytes: Vec<u8> = vec![0, 1, 2, 3, 255];    fs::write("binary.dat", &bytes)?;

    // Leitura como bytes    let read_bytes = fs::read("binary.dat")?;    println!("Lido