Trabajo con el sistema de archivos en Rust: ejemplos prácticos y consejos

Trabajo con el sistema de archivos en Rust: en la práctica

Rust es un lenguaje de sistemas moderno que le da al desarrollador control total sobre la memoria y al mismo tiempo garantiza seguridad. Trabajar con el sistema de archivos es una de las tareas básicas que se deben resolver en prácticamente cualquier proyecto. En este artículo, analizaremos cómo leer y escribir archivos, gestionar directorios y recorrer carpetas con ejemplos prácticos. Todos los ejemplos están escritos en Rust y listos para usar.

Módulos y estructuras principales

En Rust, el módulo std::fs (sistema de archivos) y std::path se encargan del trabajo con el sistema de archivos para trabajar con rutas. Los tipos clave son:

• std::fs::File — representa un archivo abierto.
• std::fs::read_dir — iterador sobre el contenido de un directorio.
• std::path::Path y std::path::PathBuf — para trabajar con rutas.

Importación de módulos:

use std::fs;use std::path::Path;

Lectura completa de un archivo

La forma más sencilla de leer un archivo de texto pequeño es usar la función fs::read_to_string. Devuelve un Result<String>.

use std::fs;

fn main() {    let content = fs::read_to_string("example.txt")        .expect("No se pudo leer el archivo");    println!("Contenido del archivo:{}", content);}

Si el archivo no existe o no hay permisos de acceso, el programa terminará con pánico. En proyectos reales, use match o el operador ? para el manejo de errores.

Manejo de errores al leer

use std::fs;

fn read_file(path: &str) -> Result<String, std::io::Error> {    fs::read_to_string(path)}

fn main() {    match read_file("config.txt") {        Ok(data) => println!("{}", data),        Err(e) => eprintln!("Error: {}", e),    }}

Escritura de datos en un archivo

Para escribir se usa fs::write (sobrescribe el archivo) o la creación de un File con opciones OpenOptions.

Escritura simple de una cadena

use std::fs;

fn main() {    let data = "Hello, Rust!";    fs::write("output.txt", data)        .expect("No se pudo escribir el archivo");    println!("Archivo escrito exitosamente");}

Añadir al final del archivo

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

fn main() {    let mut file = OpenOptions::new()        .append(true)        .create(true)        .open("log.txt")        .expect("No se pudo abrir el archivo");

    writeln!(file, "{} - registro en log", chrono::Local::now())        .expect("No se pudo escribir");}

Tenga en cuenta: OpenOptions permite configurar de forma flexible el modo: creación, sobrescritura, añadir, lectura.

Trabajo con directorios

Crear, eliminar y recorrer carpetas son tareas comunes. Veámoslas.

Creación de un nuevo directorio

use std::fs;

fn main() {    fs::create_dir("new_folder")        .expect("No se pudo crear la carpeta");    // Creación de carpetas anidadas (recursivamente)    fs::create_dir_all("parent/child/grandchild")        .expect("No se pudieron crear las carpetas anidadas");}

Eliminación de un directorio

use std::fs;

fn main() {    // Eliminar solo una carpeta vacía    fs::remove_dir("empty_folder").ok();    // Eliminación recursiva con todo el contenido    fs::remove_dir_all("temp_data")        .expect("No se pudo eliminar la carpeta");}

Tenga cuidado con remove_dir_all — elimina todo el contenido de forma irreversible.

Recorrido del contenido de un directorio

Iteración sobre archivos y carpetas dentro de un directorio:

use std::fs;

fn main() {    let entries = fs::read_dir(".")        .expect("No se pudo leer el directorio");\