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

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

Rust es un lenguaje de programación de sistemas moderno que pone un gran énfasis en la seguridad, el rendimiento y el control de la memoria. Trabajar con el sistema de archivos es una de las tareas fundamentales que todo desarrollador enfrenta. En este artículo, analizaremos en detalle cómo leer y escribir archivos, crear directorios, manejar errores y usar la biblioteca estándar std::fs para interactuar eficientemente con el sistema de archivos.

Comenzaremos desde lo más básico y pasaremos gradualmente a escenarios más complejos. Todos los ejemplos de código están escritos en Rust y listos para ejecutarse. Si recién estás empezando a aprender Rust, este artículo será un excelente punto de partida para dominar la entrada/salida (I/O) en este lenguaje.

Módulos y tipos principales para trabajar con el sistema de archivos

En Rust, toda la funcionalidad para trabajar con archivos y directorios se concentra en el módulo std::fs. Además, los tipos Path y PathBuf del módulo std::path juegan un papel importante, ya que representan rutas a archivos y directorios.

Tipos Path y PathBuf

Path es un slice (segmento) para trabajar con rutas sin poseer los datos. PathBuf es la versión propietaria que se puede modificar. Proporcionan métodos convenientes para la manipulación de rutas.

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

fn main() {    // Creación de PathBuf    let mut path = PathBuf::from("/tmp");    path.push("example.txt");    println!("Ruta: {}", path.display());

    // Conversión a Path    let path_ref: &Path = path.as_path();    println!("Directorio padre: {:?}", path_ref.parent());}

Módulo std::fs

El módulo std::fs contiene las funciones principales para trabajar con el sistema de archivos. Estas son las más utilizadas:

• read_to_string — lectura de un archivo a una cadena
• write — escritura de datos en un archivo
• create_dir y create_dir_all — creación de directorios
• remove_file y remove_dir — eliminación de archivos y directorios
• metadata — obtención de información sobre un archivo
• copy y rename — copia y renombrado

Lectura y escritura de archivos en Rust

La forma más sencilla de leer o escribir un archivo es usar funciones envolventes que realizan todo el trabajo en una sola llamada. Son adecuadas para archivos pequeños que caben completamente en la memoria.

Lectura completa de un archivo

use std::fs;

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

La función read_to_string devuelve un Result<String>. Si el archivo no existe o no hay permisos de lectura, se devolverá un error. Observe el operador ? — que propaga automáticamente el error hacia arriba.

Escritura en un archivo

use std::fs;

fn main() -> Result<(), std::io::Error> {    let data = "¡Hola, Rust!";    fs::write("output.txt", data)?;    println!("Archivo escrito exitosamente");    Ok(())}

La función write sobrescribe el archivo si existe, o crea uno nuevo. Para agregar datos al final del archivo, use OpenOptions.

Trabajo con archivos binarios

Para leer y escribir datos binarios, use read y write con un vector de bytes:

use std::fs;

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

    // Lectura como bytes    let read_bytes = fs::read("binary.dat")?;    println!("Leído