Comment lister les fichiers d'un répertoire en Rust : tutoriel pas à pas

Introduction : pourquoi pourriez-vous avoir besoin d'une liste de fichiers en Rust ?

Imaginez : vous écrivez en Rust un utilitaire de sauvegarde, un analyseur de logs ou un simple gestionnaire de fichiers. Et vous vous heurtez à une tâche basique mais cruciale : obtenir la liste de tous les fichiers dans un répertoire donné. Quoi de plus simple, apparemment ? Mais en Rust, avec son typage strict et son système de possession, même une opération aussi simple cache plusieurs pièges.

La question « How can I list files of a directory in Rust? » est l'une des plus populaires sur Stack Overflow (des milliers de vues !). Et ce n'est pas un hasard : les débutants butent souvent sur std::fs::read_dir, se perdent avec les itérateurs et oublient la gestion des erreurs. Dans ce tutoriel, je vais vous montrer deux approches fonctionnelles : une simple (uniquement les fichiers dans un seul dossier) et une avancée (parcours récursif de tous les sous-répertoires). C'est parti !

1. Préparation : création d'un nouveau projet

Avant d'écrire du code, créons un nouveau projet binaire. Ouvrez un terminal et exécutez :

cargo new list_files_rs\ncd list_files_rs

Ouvrez maintenant src/main.rs — c'est ici que nous allons écrire tout le code. Pour commencer, nous n'aurons besoin d'aucune dépendance externe, seulement de la bibliothèque standard de Rust — std.

2. La méthode la plus simple : std::fs::read_dir

La fonction std::fs::read_dir retourne un itérateur sur les entrées d'un répertoire. Chaque entrée est un DirEntry, qui contient le nom, le chemin, le type et les métadonnées du fichier. Écrivons un exemple de base :

use std::fs;\nuse std::path::Path;\n\nfn main() -> Result<(), Box<dyn std::error::Error>> {\n    let path = Path::new("."); // répertoire courant\n\n    // Lire le contenu du dossier\n    let entries = fs::read_dir(path)?;\n\n    for entry in entries {\n        let entry = entry?; // déballer le Result\n        let path = entry.path();\n\n        // Vérifier qu'il s'agit d'un fichier (pas d'un répertoire)\n        if path.is_file() {\n            println!("{}", path.display());\n        }\n    }\n\n    Ok(())\n}

Que se passe-t-il ici ?

\n
• fs::read_dir(path) — ouvre le répertoire et retourne un ReadDir (itérateur).
\n
• Nous parcourons chaque entrée. Chaque appel à next() retourne un Result<DirEntry> — d'où le besoin de entry?.
\n
• entry.path() retourne le chemin complet vers le fichier/dossier.
\n
• La méthode path.is_file() filtre les sous-répertoires.
\n

Exécutez le code avec la commande cargo run — vous verrez la liste des fichiers à la racine du projet (par exemple, Cargo.toml, src/main.rs).

2.1. Filtrage par extension

Il est souvent nécessaire d'obtenir uniquement certains fichiers, par exemple seulement les .rs ou .txt. Ajoutons un filtre :

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        // Vérifier qu'il s'agit d'un fichier et que l'extension est .rs\n        if path.is_file() && path.extension().map_or(false, |ext| ext == "rs") {\n            println!("{}", path.display());\n        }\n    }\n\n    Ok(())\n}

L'astuce avec map_or est nécessaire pour gérer en toute sécurité le cas où le fichier n'a pas d'extension — path.extension() retourne un Option<&OsStr>.

3. Parcours récursif : explorer tous les sous-dossiers

Un simple read_dir ne pénètre pas dans les sous-répertoires. Si vous devez collecter tous les fichiers de manière récursive (par exemple, pour rechercher des doublons), vous devrez écrire votre propre fonction récursive. Voici une solution élégante :

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