Comment lire et écrire des fichiers dans Rust

Suivez cette démo pour apprendre à utiliser le module de système de fichiers dans Rust.

Savoir lire et écrire des fichiers peut être utile à diverses fins. Dans Rust, cette tâche est effectuée à l'aide du module de système de fichiers (std::fs) dans la bibliothèque standard. Dans cet article, je vais vous donner un aperçu de la façon d'utiliser ce module.

Pour démontrer cette tâche, j'ai préparé un exemple de code qui est également disponible sur GitHub.

Préparation

Lors de l'utilisation de Rust, une fonction qui échoue renvoie le type de résultat. Le module de système de fichiers en particulier renvoie le type spécialisé std::io::Result. Avec cette connaissance, vous pouvez renvoyer le même type à partir de la fonction main() :

fn  main() ->  std::io::Result<()> {
/* ...code comes here... */

Écrire des fichiers Rust

Effectuer des opérations d’E/S sur des fichiers dans Rust est relativement simple. L'écriture dans un fichier peut être simplifiée en une seule ligne :

use  std::fs;
fs::write("favorite_websites.txt", b"opensource.com")?;
Ok(())

À l'aide de l'opérateur de propagation d'erreur (?), les informations d'erreur sont transmises à la fonction appelante où l'erreur peut ensuite être gérée. Comme main() est la seule autre fonction de la pile d'appels, les informations d'erreur sont transmises à la sortie de la console en cas d'échec de l'opération d'écriture.

La syntaxe de la fonction fs::write est assez avancée. Le premier argument est le chemin du fichier, qui doit être du type std::path::Path. Le deuxième argument est le contenu, qui est en fait une tranche d'octets ([u8]). Rust convertit les arguments passés dans le type correct. Heureusement, ces types sont essentiellement les seuls types traités dans les exemples suivants.

Un accès plus concis à l'opération d'écriture peut être obtenu en utilisant le type de descripteur de fichier std::fs::File :

let mut file = fs::File::create("favorite_websites.txt")?;
file.write_all(b"opensource.com\n")?;
Ok(())

Comme le type de fichier implémente le trait Write, il est possible d'utiliser les méthodes associées pour écrire dans le fichier. Cependant, la méthode create peut écraser un fichier déjà existant.

Pour obtenir encore plus de contrôle sur le descripteur de fichier, le type std::fs::OpenOptions doit être utilisé. Cela fournit des modes d'ouverture similaires à ceux des autres langues :

let mut file = fs::OpenOptions::new()
                            .append(true)
                            .open("favorite_websites.txt")?;
                            
file.write_all(b"sourceforge.net\n")?;

Lire des fichiers Rust

Ce qui s’applique à l’écriture s’applique également à la lecture. La lecture peut également se faire avec une simple ligne de code :

let websites = fs::read_to_string("favorite_websites.txt")?;

La ligne ci-dessus lit le contenu du fichier et renvoie une chaîne. En plus de lire une chaîne, il existe également la fonction std::fs::read qui lit les données dans un vecteur d'octets si le fichier contient des données binaires.

L'exemple suivant montre comment lire le contenu du fichier en mémoire et ensuite l'imprimer ligne par ligne sur une console :

let file = fs::File::open("favorite_websites.txt")?;
let lines = io::BufReader::new(file).lines();

for line in lines {
    if let Ok(_line) = line {
        println!(">>> {}", _line);
    }
}

Résumé

Si vous êtes déjà familier avec d'autres langages de programmation, vous avez peut-être remarqué qu'il n'y a aucune fonction de fermeture (ou quelque chose de similaire) qui libère le descripteur de fichier. Dans Rust, le descripteur de fichier est libéré dès que la variable associée devient hors de portée. Pour définir le comportement de fermeture, une portée ({ }) autour de la représentation du fichier peut être appliquée. Je vous recommande de vous familiariser avec les caractéristiques Lecture et Écriture , car vous pouvez trouver cette caractéristique implémentée dans de nombreux autres types.