Travailler avec le système de fichiers en Rust : exemples pratiques et conseils

Travailler avec le système de fichiers en Rust : en pratique

Rust est un langage système moderne qui donne au développeur un contrôle total sur la mémoire tout en garantissant la sécurité. Travailler avec le système de fichiers est l'une des tâches de base à résoudre dans pratiquement n'importe quel projet. Dans cet article, nous allons voir comment lire et écrire des fichiers, gérer les répertoires et parcourir les dossiers avec des exemples pratiques. Tous les exemples sont écrits en Rust et prêts à être utilisés.

Modules et structures principaux

En Rust, le module std::fs (file system) et std::path sont responsables du travail avec le système de fichiers pour la gestion des chemins. Les types clés :

• std::fs::File — représente un fichier ouvert.
• std::fs::read_dir — un itérateur sur le contenu d'un répertoire.
• std::path::Path et std::path::PathBuf — pour travailler avec les chemins.

Importation des modules :

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

Lecture complète d'un fichier

La façon la plus simple de lire un petit fichier texte est d'utiliser la fonction fs::read_to_string. Elle retourne un Result<String>.

use std::fs;

fn main() {    let content = fs::read_to_string("example.txt")        .expect("Impossible de lire le fichier");    println!("Contenu du fichier :{}", content);}

Si le fichier n'existe pas ou si les droits d'accès sont insuffisants, le programme se terminera par une panique. Dans les projets réels, utilisez match ou l'opérateur ? pour la gestion des erreurs.

Gestion des erreurs lors de la lecture

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!("Erreur : {}", e),    }}

Écrire des données dans un fichier

Pour écrire, on utilise fs::write (écrase le fichier) ou la création d'un File avec les options OpenOptions.

Écriture simple d'une chaîne

use std::fs;

fn main() {    let data = "Hello, Rust!";    fs::write("output.txt", data)        .expect("Impossible d'écrire le fichier");    println!("Fichier écrit avec succès");}

Ajout à la fin d'un fichier

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

fn main() {    let mut file = OpenOptions::new()        .append(true)        .create(true)        .open("log.txt")        .expect("Impossible d'ouvrir le fichier");

    writeln!(file, "{} - écriture dans le journal", chrono::Local::now())        .expect("Impossible d'écrire");}

Notez que OpenOptions permet de configurer flexiblement le mode — création, écrasement, ajout, lecture.

Travailler avec les répertoires

La création, la suppression et le parcours des dossiers sont des tâches courantes. Examinons-les.

Création d'un nouveau répertoire

use std::fs;

fn main() {    fs::create_dir("new_folder")        .expect("Impossible de créer le dossier");    // Création de dossiers imbriqués (récursivement)    fs::create_dir_all("parent/child/grandchild")        .expect("Impossible de créer les dossiers imbriqués");}

Suppression d'un répertoire

use std::fs;

fn main() {    // Suppression uniquement d'un dossier vide    fs::remove_dir("empty_folder").ok();    // Suppression récursive avec tout le contenu    fs::remove_dir_all("temp_data")        .expect("Impossible de supprimer le dossier");}

Soyez prudent avec remove_dir_all — il supprime définitivement tout le contenu.

Parcours du contenu d'un répertoire

Itération sur les fichiers et dossiers à l'intérieur d'un répertoire :

use std::fs;

fn main() {    let entries = fs::read_dir(".")        .expect("Impossible de lire le répertoire");\