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

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

Rust est un langage de programmation système moderne qui offre des outils puissants et sécurisés pour travailler avec le système de fichiers. Grâce à son système de types strict et à son modèle de possession, Rust permet d'éviter de nombreuses erreurs liées à la gestion des fichiers, telles que les conditions de concurrence ou les fuites de ressources. Dans cet article, nous allons détailler comment effectuer les opérations de base avec le système de fichiers en Rust : création, lecture, écriture, copie et suppression de fichiers et de répertoires. Tous les exemples de code sont écrits en utilisant la bibliothèque standard std::fs.

Préparation du projet et importation des modules

Pour commencer, créez un nouveau projet avec Cargo :

cargo new file_system_democd file_system_demo

Ouvrez le fichier src/main.rs et ajoutez les importations suivantes :

use std::fs;use std::io::{self, Write, Read};use std::path::Path;

Le module std::fs fournit des fonctions pour travailler avec les fichiers et les répertoires. std::io contient les traits pour les entrées/sorties, et std::path::Path pour travailler avec les chemins.

Création et écriture de fichiers

La façon la plus simple de créer un fichier et d'y écrire des données est d'utiliser la fonction fs::write. Elle prend le chemin du fichier et le contenu sous forme d'octets ou de chaîne de caractères.

fn main() -> io::Result<()> {    // Crée un fichier et y écrit une chaîne    fs::write("hello.txt", "Привет, Rust!")?;    println!("Fichier créé avec succès.");    Ok(())}

Si vous avez besoin de plus de contrôle, utilisez fs::File et les méthodes write ou write_all :

fn main() -> io::Result<()> {    let mut file = fs::File::create("data.txt")?;    file.write_all(b"Строка данных")?;    file.write_all("Еще одна строка".as_bytes())?;    Ok(())}

Notez l'utilisation de ? — c'est l'opérateur de propagation d'erreur. Si l'opération échoue, l'erreur sera retournée depuis la fonction.

Lecture de fichiers

Pour lire tout le contenu d'un fichier dans une chaîne, utilisez fs::read_to_string :

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

Si le fichier contient des données binaires, utilisez fs::read, qui retourne un Vec<u8> :

fn main() -> io::Result<()> {    let data = fs::read("image.png")?;    println!("Lu {} octets", data.len());    Ok(())}

Pour une lecture ligne par ligne, il est pratique d'utiliser BufReader :

fn main() -> io::Result<()> {    let file = fs::File::open("data.txt")?;    let reader = io::BufReader::new(file);    for line in reader.lines() {        let line = line?;        println!("{}", line);    }    Ok(())}

Travailler avec les répertoires

La création d'un nouveau répertoire se fait avec fs::create_dir ou fs::create_dir_all (pour les chemins imbriqués) :

fn main() -> io::Result<()> {    // Crée un seul répertoire    fs::create_dir("my_folder")?;

    // Crée des répertoires imbriqués (équivalent de mkdir -p)    fs::create_dir_all("a/b/c")?;    println!("Répertoires créés.");    Ok(())}

Pour vérifier l'existence d'un fichier ou d'un répertoire, utilisez Path::exists :

fn main() {    let path = Path::new("hello.txt");    if path.exists() {        println!("Le fichier existe.");    } else {        println!("Fichier non trouvé.");    }}

Pour obtenir la liste du contenu d'un répertoire, utilisez fs::read_dir :

fn main() -> io::Result<()> {    let e