Comment lire et écrire des 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 l’utilisation de ce module.

Pour illustrer 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 Résultat taper. Le module de système de fichiers en particulier renvoie le type spécialisé std :: io :: Résultat. Avec cette connaissance, vous pouvez renvoyer le même type à partir du main() une fonction:

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

Écriture de fichiers Rust

Effectuer des opérations d’E/S de fichiers dans Rust est relativement facile. 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(())

Utilisation de l’opérateur de propagation d’erreur (?), les informations d’erreur sont transmises à la fonction appelante où l’erreur peut ensuite être traitée. Comme main() est la seule autre fonction dans la pile des 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 fs :: écrire la fonction est assez en avant. Le premier argument est le chemin du fichier, qui doit être du type std::chemin::Chemin. 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 ::Fichier:

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 Écrire trait, il est possible d’utiliser les méthodes associées pour écrire dans le fichier. Cependant, le create La méthode 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 langages :

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

Lecture des fichiers Rust

Ce qui vaut pour l’écriture vaut aussi pour la lecture. La lecture peut aussi 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 y a aussi le std ::fs ::read fonction 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 connaissez déjà d’autres langages de programmation, vous avez peut-être remarqué qu’il existe no close-fonction (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 sort de la 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 Lire et Écrire trait car vous pouvez trouver ce trait implémenté dans de nombreux autres types.