Trabalhando com o sistema de arquivos em Rust: Guia completo

Trabalhando com o Sistema de Arquivos em Rust: Guia Completo

Rust é uma linguagem de programação de sistemas moderna que oferece ferramentas poderosas e seguras para trabalhar com o sistema de arquivos. Graças ao seu sistema de tipos rigoroso e modelo de ownership, Rust permite evitar muitos erros relacionados ao gerenciamento de arquivos, como condições de corrida ou vazamentos de recursos. Neste artigo, vamos detalhar como realizar as operações básicas com o sistema de arquivos em Rust: criação, leitura, escrita, cópia e exclusão de arquivos e diretórios. Todos os exemplos de código são escritos usando a biblioteca padrão std::fs.

Preparação do Projeto e Importação de Módulos

Para começar, crie um novo projeto usando Cargo:

cargo new file_system_democd file_system_demo

Abra o arquivo src/main.rs e adicione as seguintes importações:

use std::fs;use std::io::{self, Write, Read};use std::path::Path;

O módulo std::fs fornece funções para trabalhar com arquivos e diretórios. std::io contém traits para entrada/saída, e std::path::Path para trabalhar com caminhos.

Criação e Escrita de Arquivos

A maneira mais simples de criar um arquivo e escrever dados nele é usar a função fs::write. Ela aceita o caminho do arquivo e o conteúdo como bytes ou string.

fn main() -> io::Result<()> {    // Cria o arquivo e escreve uma string nele    fs::write("hello.txt", "Olá, Rust!")?;    println!("Arquivo criado com sucesso.");    Ok(())}

Se você precisar de mais controle, use fs::File e os métodos write ou write_all:

fn main() -> io::Result<()> {    let mut file = fs::File::create("data.txt")?;    file.write_all(b"Linha de dados")?;    file.write_all("Outra linha".as_bytes())?;    Ok(())}

Observe o ? — este é o operador de propagação de erros. Se a operação falhar, o erro será retornado da função.

Leitura de Arquivos

Para ler todo o conteúdo de um arquivo em uma string, use fs::read_to_string:

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

Se o arquivo contiver dados binários, use fs::read, que retorna um Vec<u8>:

fn main() -> io::Result<()> {    let data = fs::read("image.png")?;    println!("Lidos {} bytes", data.len());    Ok(())}

Para leitura linha por linha, é conveniente usar BufReader:

fn main() -> io::Result<()> {    let file = fs::File::open("data.txt")?;    let reader = io::BufReader::new(file);    for line in reader.lines() {        let line = line?;        println!("{}", line);    }    Ok(())}

Trabalhando com Diretórios

A criação de um novo diretório é feita com fs::create_dir ou fs::create_dir_all (para caminhos aninhados):

fn main() -> io::Result<()> {    // Cria um único diretório    fs::create_dir("my_folder")?;

    // Cria diretórios aninhados (equivalente a mkdir -p)    fs::create_dir_all("a/b/c")?;    println!("Diretórios criados.");    Ok(())}

Para verificar se um arquivo ou diretório existe, use Path::exists:

fn main() {    let path = Path::new("hello.txt");    if path.exists() {        println!("Arquivo existe.");    } else {        println!("Arquivo não encontrado.");    }}

Obter a lista de conteúdo de um diretório pode ser feito com fs::read_dir:

fn main() -> io::Result<()> {    let e