Trabajo con el sistema de archivos en Rust: guía práctica

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

Rust es un lenguaje de programación de sistemas moderno que combina alto rendimiento y seguridad de memoria. Una de las tareas clave que enfrenta todo desarrollador es trabajar con el sistema de archivos. En este artículo, analizaremos con ejemplos prácticos cómo leer y escribir archivos, crear directorios, manejar errores y realizar otras operaciones con el sistema de archivos en Rust.

Módulos principales para trabajar con el sistema de archivos

En Rust, todo el trabajo con el sistema de archivos se concentra en la biblioteca estándar. Los módulos principales son:

\n
• std::fs — funciones para trabajar con archivos y directorios (lectura, escritura, creación, eliminación).
\n
• std::path — trabajo con rutas (Path, PathBuf).
\n
• std::io — entrada/salida, incluyendo los traits Read y Write.
\n

Para empezar, basta con importar los módulos necesarios:

use std::fs;\nuse std::path::Path;\nuse std::io::prelude::*;\nuse std::fs::File;

Lectura de archivos en Rust

La forma más sencilla de leer un archivo completo es usar la función fs::read_to_string. Esta devuelve un Result<String>, lo que permite manejar errores de manera conveniente.

use std::fs;\n\nfn main() {\n    let file_path = "example.txt";\n    \n    match fs::read_to_string(file_path) {\n        Ok(content) => println!("Contenido del archivo:\\n{}", content),\n        Err(e) => eprintln!("Error al leer el archivo: {}", e),\n    }\n}

Si necesitas leer el archivo línea por línea (por ejemplo, para archivos grandes), usa BufReader:

use std::fs::File;\nuse std::io::{BufRead, BufReader};\n\nfn main() {\n    let file = File::open("example.txt").expect("No se pudo abrir el archivo");\n    let reader = BufReader::new(file);\n\n    for line in reader.lines() {\n        match line {\n            Ok(content) => println!("{}", content),\n            Err(e) => eprintln!("Error al leer la línea: {}", e),\n        }\n    }\n}

Escritura de datos en archivos

Para escribir datos en un archivo, usa fs::write (escritura simple de una cadena) o File::create seguido de escritura con write! o writeln!.

use std::fs;\n\nfn main() {\n    let content = "¡Hola, mundo!\\nEsta es una línea para escribir.";\n    fs::write("output.txt", content).expect("Error al escribir el archivo");\n    println!("Archivo escrito exitosamente");\n}

Para escritura secuencial o añadir datos, usa OpenOptions:

use std::fs::OpenOptions;\nuse std::io::Write;\n\nfn main() {\n    let mut file = OpenOptions::new()\n        .append(true)  // añadir al archivo\n        .create(true)  // crear si no existe\n        .open("log.txt")\n        .expect("No se pudo abrir el archivo");\n\n    writeln!(file, "Registro en log: {}", chrono::Local::now()).expect("Error al escribir");\n}

Trabajo con directorios y rutas

Rust proporciona herramientas convenientes para crear, eliminar y recorrer directorios. Veamos las operaciones principales.

Creación y eliminación de directorios

use std::fs;\n\nfn main() {\n    // Crear un directorio\n    fs::create_dir("new_folder").expect("Error al crear el directorio");\n    \n    // Crear directorios anidados (equivalente a mkdir -p)\n    fs::create_dir_all("parent/child/grandchild").expect("Error al crear directorios anidados");\n    \n    // Eliminar un directorio vacío\n    fs::remove_dir("new_folder").expect("Error al eliminar el directorio");\n    \n    // Eliminar un directorio con todo su contenido\n    fs::remove_dir_all("parent").expect("Error al eliminar el directorio con contenido");\n}

Recorrer el contenido de un directorio

Para obtener la lista de archivos