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

Introduction au travail avec le système de fichiers en Rust

Rust est un langage de programmation système moderne qui offre des moyens puissants et sécurisés pour interagir avec le système de fichiers. Contrairement à de nombreux autres langages, Rust garantit la sécurité de la mémoire et des threads, ce qui est particulièrement important pour les opérations d'entrée-sortie. Dans cet article, nous allons détailler comment créer, lire, écrire des fichiers et des répertoires, gérer les chemins et traiter les erreurs à l'aide de la bibliothèque standard std::fs et std::path.

Ce matériel sera utile aussi bien aux débutants qui découvrent Rust qu'aux développeurs expérimentés souhaitant rafraîchir leurs connaissances. Tous les exemples de code sont prêts à être exécutés et sont accompagnés de commentaires.

Modules principaux et imports

Pour travailler avec le système de fichiers en Rust, deux modules clés sont utilisés :

• std::fs — fournit des fonctions pour les opérations sur les fichiers et dossiers (lecture, écriture, suppression, copie, etc.).
• std::path — contient les types Path et PathBuf pour la gestion des chemins.

Pour la plupart des tâches, il suffit d'ajouter les imports suivants :

use std::fs;use std::path::Path;use std::io::prelude::*; // pour travailler avec les flux

Travail avec les fichiers : lecture et écriture

Lecture du contenu d'un fichier

La façon la plus simple de lire tout un fichier dans une chaîne de caractères est d'utiliser la fonction fs::read_to_string. Elle retourne un Result<String>, il faut donc gérer l'erreur potentielle.

use std::fs;

fn read_file(path: &str) -> Result<String, std::io::Error> {    let content = fs::read_to_string(path)?;    Ok(content)}

fn main() {    match read_file("example.txt") {        Ok(text) => println!("Contenu du fichier :{}", text),        Err(e) => eprintln!("Erreur de lecture : {}", e),    }}

Si vous devez lire un fichier sous forme de données binaires, utilisez fs::read, qui retourne un Vec<u8>.

Écriture dans un fichier

Pour écrire une chaîne de caractères dans un fichier, on utilise fs::write. Elle crée le fichier s'il n'existe pas, ou écrase le fichier existant.

use std::fs;

fn write_file(path: &str, content: &str) -> Result<(), std::io::Error> {    fs::write(path, content)?;    println!("Fichier écrit avec succès");    Ok(())}

fn main() {    let data = "Hello, Rust!Deuxième ligne.";    if let Err(e) = write_file("output.txt", data) {        eprintln!("Erreur d'écriture : {}", e);    }}

Pour ajouter à la fin d'un fichier ou pour un contrôle plus fin, utilisez OpenOptions :

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

fn append_to_file(path: &str, line: &str) -> Result<(), std::io::Error> {    let mut file = OpenOptions::new()        .append(true)        .create(true)        .open(path)?;    writeln!(file, "{}", line)?;    Ok(())}

Travail avec les répertoires

Création et suppression de dossiers

Pour créer un répertoire, utilisez fs::create_dir (un seul dossier) ou fs::create_dir_all (récursivement, comme mkdir -p).

use std::fs;

fn main() -> Result<(), std::io::Error> {    // Création d'un seul dossier    fs::create_dir("my_folder")?;

    // Création récursive de dossiers imbriqués    fs::create_dir_all("data/subdir/logs")?;

    // Suppression d'un dossier vide    fs::remove_dir("my_folder")?;

    // Suppression récursive d'un dossier avec tout son contenu    fs::remove_dir_all("data")?;

    Ok(())}

Lecture du contenu d'un répertoire

La fonction fs::read_dir retourne un itérateur sur les entrées du répertoire. Chaque entrée est un DirEntry, à partir duquel on peut obtenir le nom, le type et les métadonnées.

use std::fs;

fn list_directory(path: