Cómo listar archivos en un directorio en Rust: tutorial paso a paso

Introducción: ¿por qué podrías necesitar listar archivos en Rust?

Imagina: estás escribiendo en Rust una utilidad de respaldo, un analizador de registros o un simple administrador de archivos. Y surge una tarea básica pero crítica: obtener la lista de todos los archivos en un directorio específico. Parece sencillo, ¿verdad? Pero en Rust, con su tipado estricto y su sistema de propiedad, incluso una operación tan simple esconde varios obstáculos.

La pregunta «How can I list files of a directory in Rust?» es una de las más populares en Stack Overflow (¡miles de visitas!). Y no es casualidad: los principiantes a menudo tropiezan con std::fs::read_dir, se confunden con los iteradores y olvidan el manejo de errores. En este tutorial te mostraré dos enfoques funcionales: uno simple (solo archivos en una carpeta) y uno avanzado (recorrido recursivo de todos los subdirectorios). ¡Vamos allá!

1. Preparación: creamos un nuevo proyecto

Antes de escribir código, creemos un nuevo proyecto binario. Abre la terminal y ejecuta:

cargo new list_files_rs\ncd list_files_rs

Ahora abre src/main.rs — aquí escribiremos todo el código. Para empezar, no necesitaremos dependencias externas, solo la biblioteca estándar de Rust — std.

2. La forma más simple: std::fs::read_dir

La función std::fs::read_dir devuelve un iterador sobre las entradas del directorio. Cada entrada es un DirEntry, que contiene el nombre, la ruta, el tipo y los metadatos del archivo. Escribamos un ejemplo básico:

use std::fs;\nuse std::path::Path;\n\nfn main() -> Result<(), Box<dyn std::error::Error>> {\n    let path = Path::new("."); // directorio actual\n\n    // Leemos el contenido de la carpeta\n    let entries = fs::read_dir(path)?;\n\n    for entry in entries {\n        let entry = entry?; // desempaquetamos el Result\n        let path = entry.path();\n\n        // Verificamos que sea un archivo (no un directorio)\n        if path.is_file() {\n            println!("{}", path.display());\n        }\n    }\n\n    Ok(())\n}

¿Qué sucede aquí?

\n
• fs::read_dir(path) — abre el directorio y devuelve un ReadDir (iterador).
\n
• Recorremos cada entrada. Cada llamada a next() devuelve un Result<DirEntry> — por eso necesitamos entry?.
\n
• entry.path() devuelve la ruta completa al archivo/carpeta.
\n
• El método path.is_file() filtra los subdirectorios.
\n

Ejecuta el código con el comando cargo run — verás la lista de archivos en la raíz del proyecto (por ejemplo, Cargo.toml, src/main.rs).

2.1. Filtrado por extensión

A menudo necesitas solo ciertos archivos, por ejemplo, solo .rs o .txt. Añadamos un filtro:

use std::fs;\nuse std::path::Path;\n\nfn main() -> Result<(), Box<dyn std::error::Error>> {\n    let path = Path::new(".");\n\n    for entry in fs::read_dir(path)? {\n        let entry = entry?;\n        let path = entry.path();\n\n        // Verificamos que sea un archivo y extensión .rs\n        if path.is_file() && path.extension().map_or(false, |ext| ext == "rs") {\n            println!("{}", path.display());\n        }\n    }\n\n    Ok(())\n}

El truco con map_or es necesario para manejar de forma segura el caso en que el archivo no tiene extensión — path.extension() devuelve Option<&OsStr>.

3. Recorrido recursivo: explorando todas las subcarpetas

El simple read_dir no entra en los subdirectorios. Si necesitas recopilar todos los archivos de forma recursiva (por ejemplo, para buscar duplicados), tendrás que escribir tu propia función recursiva. Aquí tienes una solución elegante:

use std::fs;\nuse std::path::Path;\n\nfn visit_dirs(dir: &Path, depth: usize) -> Result<(), Box&l