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

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

Rust est un langage de programmation système moderne qui allie hautes performances et sécurité mémoire. L'une des tâches clés que chaque développeur rencontre est le travail avec le système de fichiers. Dans cet article, nous allons voir, à l'aide d'exemples pratiques, comment lire et écrire des fichiers, créer des répertoires, gérer les erreurs et effectuer d'autres opérations avec le système de fichiers en Rust.

Modules principaux pour travailler avec le système de fichiers

En Rust, tout le travail avec le système de fichiers est concentré dans la bibliothèque standard. Les modules principaux :

\n
• std::fs — fonctions pour travailler avec les fichiers et les répertoires (lecture, écriture, création, suppression).
\n
• std::path — travail avec les chemins (Path, PathBuf).
\n
• std::io — entrées-sorties, incluant les traits Read et Write.
\n

Pour commencer, il suffit d'importer les modules nécessaires :

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

Lecture de fichiers en Rust

La façon la plus simple de lire un fichier entier est d'utiliser la fonction fs::read_to_string. Elle retourne un Result<String>, ce qui permet de gérer facilement les erreurs.

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!("Contenu du fichier :\\n{}", content),\n        Err(e) => eprintln!("Erreur de lecture du fichier : {}", e),\n    }\n}

Si vous devez lire un fichier ligne par ligne (par exemple, pour les gros fichiers), utilisez BufReader :

use std::fs::File;\nuse std::io::{BufRead, BufReader};\n\nfn main() {\n    let file = File::open("example.txt").expect("Impossible d'ouvrir le fichier");\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!("Erreur de lecture de la ligne : {}", e),\n        }\n    }\n}

Écriture de données dans des fichiers

Pour écrire des données dans un fichier, utilisez fs::write (écriture simple d'une chaîne) ou File::create suivi d'une écriture via write! ou writeln!.

use std::fs;\n\nfn main() {\n    let content = "Bonjour, le monde !\\nCeci est une ligne à écrire.";\n    fs::write("output.txt", content).expect("Erreur d'écriture du fichier");\n    println!("Fichier écrit avec succès");\n}

Pour une écriture séquentielle ou l'ajout de données, utilisez OpenOptions :

use std::fs::OpenOptions;\nuse std::io::Write;\n\nfn main() {\n    let mut file = OpenOptions::new()\n        .append(true)  // ajout au fichier\n        .create(true)  // créer s'il n'existe pas\n        .open("log.txt")\n        .expect("Impossible d'ouvrir le fichier");\n\n    writeln!(file, "Écriture dans le journal : {}", chrono::Local::now()).expect("Erreur d'écriture");\n}

Travail avec les répertoires et les chemins

Rust fournit des outils pratiques pour créer, supprimer et parcourir les répertoires. Examinons les opérations principales.

Création et suppression de répertoires

use std::fs;\n\nfn main() {\n    // Création d'un seul répertoire\n    fs::create_dir("new_folder").expect("Erreur de création du répertoire");\n    \n    // Création de répertoires imbriqués (équivalent de mkdir -p)\n    fs::create_dir_all("parent/child/grandchild").expect("Erreur de création des répertoires imbriqués");\n    \n    // Suppression d'un répertoire vide\n    fs::remove_dir("new_folder").expect("Erreur de suppression du répertoire");\n    \n    // Suppression d'un répertoire avec tout son contenu\n    fs::remove_dir_all("parent").expect("Erreur de suppression du répertoire avec son contenu");\n}

Parcours du contenu d'un répertoire

Pour obtenir la liste des fichiers