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

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

Rust es un lenguaje de programación de sistemas moderno que ofrece herramientas potentes y seguras para trabajar con el sistema de archivos. Gracias a su estricto sistema de tipos y modelo de propiedad, Rust permite evitar muchos errores relacionados con la gestión de archivos, como condiciones de carrera o fugas de recursos. En este artículo, analizaremos en detalle cómo realizar las operaciones básicas con el sistema de archivos en Rust: creación, lectura, escritura, copia y eliminación de archivos y directorios. Todos los ejemplos de código están escritos utilizando la biblioteca estándar std::fs.

Preparación del proyecto e importación de módulos

Para comenzar, cree un nuevo proyecto con Cargo:

cargo new file_system_democd file_system_demo

Abra el archivo src/main.rs y agregue las siguientes importaciones:

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

El módulo std::fs proporciona funciones para trabajar con archivos y directorios. std::io contiene traits para entrada/salida, y std::path::Path para trabajar con rutas.

Creación y escritura de archivos

La forma más sencilla de crear un archivo y escribir datos en él es usar la función fs::write. Esta recibe la ruta al archivo y el contenido en forma de bytes o cadena.

fn main() -> io::Result<()> {    // Creamos el archivo y escribimos una cadena en él    fs::write("hello.txt", "¡Hola, Rust!")?;    println!("Archivo creado exitosamente.");    Ok(())}

Si necesita más control, use fs::File y los métodos write o write_all:

fn main() -> io::Result<()> {    let mut file = fs::File::create("data.txt")?;    file.write_all(b"Línea de datos")?;    file.write_all("Otra línea más".as_bytes())?;    Ok(())}

Observe el ? — es el operador de propagación de errores. Si la operación falla, el error será retornado desde la función.

Lectura de archivos

Para leer todo el contenido de un archivo en una cadena, use fs::read_to_string:

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

Si el archivo contiene datos binarios, use fs::read, que devuelve un Vec<u8>:

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

Para lectura línea por línea, es 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(())}

Trabajo con directorios

La creación de un nuevo directorio se realiza con fs::create_dir o fs::create_dir_all (para rutas anidadas):

fn main() -> io::Result<()> {    // Creamos un directorio    fs::create_dir("my_folder")?;

    // Creamos directorios anidados (equivalente a mkdir -p)    fs::create_dir_all("a/b/c")?;    println!("Directorios creados.");    Ok(())}

Para verificar la existencia de un archivo o directorio, use Path::exists:

fn main() {    let path = Path::new("hello.txt");    if path.exists() {        println!("El archivo existe.");    } else {        println!("Archivo no encontrado.");    }}

Obtener la lista del contenido de un directorio se puede hacer con fs::read_dir:

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