Rust: input / output di file

Oltre a leggere e scrivere su console, Rust permette di leggere e scrivere su file.

La struttura File rappresenta un file. Consente a un programma di eseguire operazioni di lettura-scrittura su un file. Tutti i metodi nella struttura File restituiscono una variante dell'enumerazione io :: Result.

I metodi comunemente usati della struttura File sono elencati nella tabella seguente:

Suor n Modulo Metodo Firma Descrizione
1 std :: fs :: File Aperto() pub fn open <P: AsRef> (percorso: P) -> Risultato Il metodo statico aperto può essere utilizzato per aprire un file in modalità di sola lettura.
2 std :: fs :: File creare() pub fn create <P: AsRef> (percorso: P) -> Risultato Il metodo statico apre un file in modalità di sola scrittura. Se il file esisteva già, il vecchio contenuto viene distrutto. In caso contrario, viene creato un nuovo file.
3 std :: fs :: remove_file Rimuovi il file() pub fn remove_file <P: AsRef> (percorso: P) -> Risultato <()> Rimuove un file dal filesystem. Non vi è alcuna garanzia che il file venga immediatamente eliminato.
4 std :: fs :: OpenOptions aggiungere() pub fn append (& mut self, append: bool) -> & mut OpenOptions Imposta l'opzione per la modalità di aggiunta del file.
5 std :: io :: scrive write_all () fn write_all (& mut self, buf: & [u8]) -> Risultato <()> Tenta di scrivere un intero buffer in questa scrittura.
6 std :: io :: Leggi read_to_string () fn read_to_string (& mut self, buf: & mut String) -> Risultato Legge tutti i byte fino all'EOF in questa sorgente, aggiungendoli a buf.

Scrivi su un file

Vediamo un esempio per capire come scrivere un file.

Il seguente programma crea un file "data.txt". Il metodo create () viene utilizzato per creare un file. Il metodo restituisce un handle di file se il file viene creato correttamente. L'ultima riga della funzione write_all scriverà i byte nel file appena creato. Se una qualsiasi delle operazioni fallisce, la funzione wait () restituisce un messaggio di errore.

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

Produzione

data written to file

Leggi da un file

Il seguente programma legge il contenuto in un file data.txt e lo stampa sulla console. La funzione "apri" viene utilizzata per aprire un file esistente. Un percorso assoluto o relativo del file viene passato alla funzione open () come parametro. La funzione open () genera un'eccezione se il file non esiste o se non è accessibile per qualsiasi motivo. Se riesce, un handle di file a tale file viene assegnato alla variabile "file".

La funzione "read_to_string" dell'handle "file" viene utilizzata per leggere il contenuto di quel file in una variabile stringa.

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

Produzione

Hello World
TutorialsPoint

Elimina un file

L'esempio seguente utilizza la funzione remove_file () per eliminare un file. La funzione wait () restituisce un messaggio personalizzato nel caso si verifichi un errore.

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

Produzione

file is removed

Aggiungi dati a un file

La funzione append () scrive i dati alla fine del file. Questo è mostrato nell'esempio fornito di seguito:

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

Produzione

file append success

Copia un file

L'esempio seguente copia il contenuto di un file in un nuovo file.

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

Esegui il programma sopra come main.exe data.txt datacopy.txt . Durante l'esecuzione del file vengono passati due argomenti della riga di comando:

  • il percorso del file di origine
  • il file di destinazione