Trabajo con el sistema de archivos en Rust: guía completa

Introducción al trabajo con el sistema de archivos en Rust

Rust es un lenguaje de programación de sistemas moderno que ofrece herramientas potentes y seguras para interactuar con el sistema de archivos. A diferencia de muchos otros lenguajes, Rust garantiza la seguridad en el manejo de memoria y hilos, lo cual es especialmente importante en operaciones de entrada/salida. En este artículo analizaremos en detalle cómo crear, leer, escribir archivos y directorios, gestionar rutas y manejar errores utilizando la biblioteca estándar std::fs y std::path.

El material será útil tanto para principiantes que recién se familiarizan con Rust, como para desarrolladores experimentados que deseen refrescar sus conocimientos. Todos los ejemplos de código están listos para ejecutarse y vienen acompañados de comentarios.

Módulos principales e imports

Para trabajar con el sistema de archivos en Rust se utilizan dos módulos clave:

• std::fs — proporciona funciones para operaciones con archivos y carpetas (lectura, escritura, eliminación, copia, etc.).
• std::path — contiene los tipos Path y PathBuf para trabajar con rutas.

Para la mayoría de las tareas es suficiente agregar los siguientes imports:

use std::fs;use std::path::Path;use std::io::prelude::*; // para trabajar con flujos

Trabajo con archivos: lectura y escritura

Lectura del contenido de un archivo

La forma más sencilla de leer un archivo completo en una cadena es usar la función fs::read_to_string. Esta devuelve un Result<String>, por lo que es necesario manejar el posible error.

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!("Contenido del archivo:{}", text),        Err(e) => eprintln!("Error de lectura: {}", e),    }}

Si necesita leer un archivo como datos binarios, use fs::read, que devuelve un Vec<u8>.

Escritura en un archivo

Para escribir una cadena en un archivo se utiliza fs::write. Esta creará el archivo si no existe, o sobrescribirá el existente.

use std::fs;

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

fn main() {    let data = "Hello, Rust!Segunda línea.";    if let Err(e) = write_file("output.txt", data) {        eprintln!("Error de escritura: {}", e);    }}

Para añadir al final de un archivo o tener un control más preciso, 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(())}

Trabajo con directorios

Creación y eliminación de carpetas

Para crear un directorio use fs::create_dir (una carpeta) o fs::create_dir_all (recursivamente, como mkdir -p).

use std::fs;

fn main() -> Result<(), std::io::Error> {    // Creación de una carpeta    fs::create_dir("my_folder")?;

    // Creación recursiva de carpetas anidadas    fs::create_dir_all("data/subdir/logs")?;

    // Eliminación de una carpeta vacía    fs::remove_dir("my_folder")?;

    // Eliminación recursiva de una carpeta con todo su contenido    fs::remove_dir_all("data")?;

    Ok(())}

Lectura del contenido de un directorio

La función fs::read_dir devuelve un iterador sobre las entradas del directorio. Cada entrada es un DirEntry, del cual se puede obtener el nombre, tipo y metadatos.

use std::fs;

fn list_directory(path: