Rust - Entrée / sortie de fichier

En plus de lire et d'écrire sur la console, Rust permet de lire et d'écrire dans des fichiers.

La structure File représente un fichier. Il permet à un programme d'effectuer des opérations de lecture-écriture sur un fichier. Toutes les méthodes de la structure File renvoient une variante de l'énumération io :: Result.

Les méthodes couramment utilisées de la structure File sont répertoriées dans le tableau ci-dessous -

Sr. Non Module Méthode Signature La description
1 std :: fs :: Fichier ouvert() pub fn open <P: AsRef> (chemin: P) -> Résultat La méthode statique ouverte peut être utilisée pour ouvrir un fichier en mode lecture seule.
2 std :: fs :: Fichier créer() pub fn create <P: AsRef> (chemin: P) -> Résultat La méthode statique ouvre un fichier en mode écriture seule. Si le fichier existait déjà, l'ancien contenu est détruit. Sinon, un nouveau fichier est créé.
3 std :: fs :: remove_file effacer le fichier() pub fn remove_file <P: AsRef> (chemin: P) -> Résultat <()> Supprime un fichier du système de fichiers. Il n'y a aucune garantie que le fichier soit immédiatement supprimé.
4 std :: fs :: OpenOptions ajouter() pub fn append (& mut self, append: bool) -> & mut OpenOptions Définit l'option pour le mode d'ajout du fichier.
5 std :: io :: Écrit write_all () fn write_all (& mut self, buf: & [u8]) -> Résultat <()> Tente d'écrire un tampon entier dans cette écriture.
6 std :: io :: Read read_to_string () fn read_to_string (& mut self, buf: & mut String) -> Résultat Lit tous les octets jusqu'à EOF dans cette source, en les ajoutant à buf.

Écrire dans un fichier

Voyons un exemple pour comprendre comment écrire un fichier.

Le programme suivant crée un fichier 'data.txt'. La méthode create () est utilisée pour créer un fichier. La méthode renvoie un descripteur de fichier si le fichier est créé avec succès. La dernière ligne de la fonction write_all écrira des octets dans le fichier nouvellement créé. Si l'une des opérations échoue, la fonction expect () renvoie un message d'erreur.

use std::io::Write;
fn main() {
   let mut file = std::fs::File::create("data.txt").expect("create failed");
   file.write_all("Hello World".as_bytes()).expect("write failed");
   file.write_all("\nTutorialsPoint".as_bytes()).expect("write failed");
   println!("data written to file" );
}

Production

data written to file

Lire à partir d'un fichier

Le programme suivant lit le contenu d'un fichier data.txt et l'imprime sur la console. La fonction "ouvrir" permet d'ouvrir un fichier existant. Un chemin absolu ou relatif vers le fichier est passé à la fonction open () en tant que paramètre. La fonction open () lève une exception si le fichier n'existe pas ou s'il n'est pas accessible pour une raison quelconque. Si cela réussit, un descripteur de fichier pour ce fichier est affecté à la variable "fichier".

La fonction "read_to_string" du handle "file" est utilisée pour lire le contenu de ce fichier dans une variable chaîne.

use std::io::Read;

fn main(){
   let mut file = std::fs::File::open("data.txt").unwrap();
   let mut contents = String::new();
   file.read_to_string(&mut contents).unwrap();
   print!("{}", contents);
}

Production

Hello World
TutorialsPoint

Supprimer un fichier

L'exemple suivant utilise la fonction remove_file () pour supprimer un fichier. La fonction expect () renvoie un message personnalisé en cas d'erreur.

use std::fs;
fn main() {
   fs::remove_file("data.txt").expect("could not remove file");
   println!("file is removed");
}

Production

file is removed

Ajouter des données à un fichier

La fonction append () écrit les données à la fin du fichier. Ceci est illustré dans l'exemple ci-dessous -

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

fn main() {
   let mut file = OpenOptions::new().append(true).open("data.txt").expect(
      "cannot open file");
   file.write_all("Hello World".as_bytes()).expect("write failed");
   file.write_all("\nTutorialsPoint".as_bytes()).expect("write failed");
   println!("file append success");
}

Production

file append success

Copier un fichier

L'exemple suivant copie le contenu d'un fichier dans un nouveau fichier.

use std::io::Read;
use std::io::Write;

fn main() {
   let mut command_line: std::env::Args = std::env::args();
   command_line.next().unwrap();
   // skip the executable file name
   // accept the source file
   let source = command_line.next().unwrap();
   // accept the destination file
   let destination = command_line.next().unwrap();
   let mut file_in = std::fs::File::open(source).unwrap();
   let mut file_out = std::fs::File::create(destination).unwrap();
   let mut buffer = [0u8; 4096];
   loop {
      let nbytes = file_in.read(&mut buffer).unwrap();
      file_out.write(&buffer[..nbytes]).unwrap();
      if nbytes < buffer.len() { break; }
   }
}

Exécutez le programme ci-dessus en tant que main.exe data.txt datacopy.txt . Deux arguments de ligne de commande sont passés lors de l'exécution du fichier -

  • le chemin vers le fichier source
  • le fichier de destination