Rust - Dateieingabe / -ausgabe

Neben dem Lesen und Schreiben auf der Konsole ermöglicht Rust das Lesen und Schreiben in Dateien.

Die Dateistruktur repräsentiert eine Datei. Es ermöglicht einem Programm, Lese- / Schreibvorgänge für eine Datei auszuführen. Alle Methoden in der Dateistruktur geben eine Variante der io :: Result-Enumeration zurück.

Die häufig verwendeten Methoden der Dateistruktur sind in der folgenden Tabelle aufgeführt:

Sr.Nr.	Modul	Methode	Unterschrift	Beschreibung
1	std :: fs :: File	öffnen()	pub fn open <P: AsRef> (Pfad: P) -> Ergebnis	Mit der Methode open static kann eine Datei im schreibgeschützten Modus geöffnet werden.
2	std :: fs :: File	erstellen()	pub fn create <P: AsRef> (Pfad: P) -> Ergebnis	Die statische Methode öffnet eine Datei im Nur-Schreib-Modus. Wenn die Datei bereits vorhanden war, wird der alte Inhalt zerstört. Andernfalls wird eine neue Datei erstellt.
3	std :: fs :: remove_file	Datei löschen()	pub fn remove_file <P: AsRef> (Pfad: P) -> Ergebnis <()>	Entfernt eine Datei aus dem Dateisystem. Es gibt keine Garantie dafür, dass die Datei sofort gelöscht wird.
4	std :: fs :: OpenOptions	append ()	pub fn append (& mut self, append: bool) -> & mut OpenOptions	Legt die Option für den Anhänge-Modus der Datei fest.
5	std :: io :: Writes	write_all ()	fn write_all (& mut self, buf: & [u8]) -> Ergebnis <()>	Versuche, einen gesamten Puffer in diesen Schreibvorgang zu schreiben.
6	std :: io :: Read	read_to_string ()	fn read_to_string (& mut self, buf: & mut String) -> Ergebnis	Liest alle Bytes bis EOF in dieser Quelle und hängt sie an buf an.

In eine Datei schreiben

Sehen wir uns ein Beispiel an, um zu verstehen, wie eine Datei geschrieben wird.

Das folgende Programm erstellt eine Datei 'data.txt'. Mit der Methode create () wird eine Datei erstellt. Die Methode gibt ein Dateihandle zurück, wenn die Datei erfolgreich erstellt wurde. Die Funktion write_all in der letzten Zeile schreibt Bytes in die neu erstellte Datei. Wenn eine der Operationen fehlschlägt, gibt die Funktion expected () eine Fehlermeldung zurück.

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" );
}

Ausgabe

data written to file

Aus einer Datei lesen

Das folgende Programm liest den Inhalt einer Datei data.txt und druckt ihn auf der Konsole aus. Mit der Funktion "Öffnen" wird eine vorhandene Datei geöffnet. Ein absoluter oder relativer Pfad zur Datei wird als Parameter an die Funktion open () übergeben. Die Funktion open () löst eine Ausnahme aus, wenn die Datei nicht vorhanden ist oder aus irgendeinem Grund nicht zugänglich ist. Wenn dies erfolgreich ist, wird der Variablen "file" ein Dateihandle für eine solche Datei zugewiesen.

Die Funktion "read_to_string" des Handles "file" wird verwendet, um den Inhalt dieser Datei in eine Zeichenfolgenvariable einzulesen.

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);
}

Ausgabe

Hello World
TutorialsPoint

Löschen Sie eine Datei

Im folgenden Beispiel wird die Funktion remove_file () verwendet, um eine Datei zu löschen. Die Funktion expected () gibt eine benutzerdefinierte Nachricht zurück, falls ein Fehler auftritt.

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

Ausgabe

file is removed

Daten an eine Datei anhängen

Die Funktion append () schreibt Daten an das Ende der Datei. Dies wird im folgenden Beispiel gezeigt -

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");
}

Ausgabe

file append success

Kopieren Sie eine Datei

Im folgenden Beispiel wird der Inhalt einer Datei in eine neue Datei kopiert.

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; }
   }
}

Führen Sie das obige Programm als main.exe data.txt datacopy.txt aus . Beim Ausführen der Datei werden zwei Befehlszeilenargumente übergeben -

der Pfad zur Quelldatei
die Zieldatei