Travail avec le système de fichiers en Rust : guide complet pour débutants

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

Rust est un langage de programmation système moderne qui accorde une grande importance à la sécurité, aux performances et au contrôle de la mémoire. Le travail avec le système de fichiers est l'une des tâches fondamentales que chaque développeur rencontre. Dans cet article, nous allons détailler comment lire et écrire des fichiers, créer des répertoires, gérer les erreurs et utiliser la bibliothèque standard std::fs pour interagir efficacement avec le système de fichiers.

Nous commencerons par les bases et passerons progressivement à des scénarios plus complexes. Tous les exemples de code sont écrits en Rust et prêts à être exécutés. Si vous commencez tout juste à apprendre Rust, cet article sera un excellent point de départ pour maîtriser les entrées-sorties (I/O) dans ce langage.

Modules et types principaux pour le travail avec le système de fichiers

En Rust, toutes les fonctionnalités pour travailler avec les fichiers et les répertoires sont regroupées dans le module std::fs. De plus, les types Path et PathBuf du module std::path jouent un rôle important en représentant les chemins vers les fichiers et les répertoires.

Types Path et PathBuf

Path est une tranche (slice) pour travailler avec les chemins sans posséder les données. PathBuf est la version propriétaire, qui peut être modifiée. Ils fournissent des méthodes pratiques pour manipuler les chemins.

use std::path::Path;use std::path::PathBuf;

fn main() {    // Création d'un PathBuf    let mut path = PathBuf::from("/tmp");    path.push("example.txt");    println!("Chemin : {}", path.display());

    // Conversion en Path    let path_ref: &Path = path.as_path();    println!("Répertoire parent : {:?}", path_ref.parent());}

Module std::fs

Le module std::fs contient les fonctions principales pour travailler avec le système de fichiers. Voici les plus couramment utilisées :

• read_to_string — lecture d'un fichier dans une chaîne de caractères
• write — écriture de données dans un fichier
• create_dir et create_dir_all — création de répertoires
• remove_file et remove_dir — suppression de fichiers et de répertoires
• metadata — obtention d'informations sur un fichier
• copy et rename — copie et renommage

Lecture et écriture de fichiers en Rust

La façon la plus simple de lire ou d'écrire un fichier est d'utiliser des fonctions d'encapsulation qui effectuent tout le travail en un seul appel. Elles conviennent pour les petits fichiers qui tiennent entièrement en mémoire.

Lecture complète d'un fichier

use std::fs;

fn main() -> Result<(), std::io::Error> {    let content = fs::read_to_string("hello.txt")?;    println!("Contenu du fichier :{}", content);    Ok(())}

La fonction read_to_string retourne un Result<String>. Si le fichier n'existe pas ou si les droits de lecture sont insuffisants, une erreur sera retournée. Notez l'opérateur ? — il propage automatiquement l'erreur vers le haut.

Écriture dans un fichier

use std::fs;

fn main() -> Result<(), std::io::Error> {    let data = "Bonjour, Rust !";    fs::write("output.txt", data)?;    println!("Fichier écrit avec succès");    Ok(())}

La fonction write écrase le fichier s'il existe, ou en crée un nouveau. Pour ajouter des données à la fin d'un fichier, utilisez OpenOptions.

Travail avec les fichiers binaires

Pour lire et écrire des données binaires, utilisez read et write avec un vecteur d'octets :

use std::fs;

fn main() -> Result<(), std::io::Error> {    // Écriture de données binaires    let bytes: Vec<u8> = vec![0, 1, 2, 3, 255];    fs::write("binary.dat", &bytes)?;

    // Lecture en tant qu'octets    let read_bytes = fs::read("binary.dat")?;    println!("Lu