Rust - Input Output

Questo capitolo spiega come accettare i valori dallo standard input (tastiera) e visualizzare i valori nello standard output (console). In questo capitolo, discuteremo anche del passaggio di argomenti della riga di comando.

Tipi di lettori e scrittori

Le funzionalità della libreria standard di Rust per input e output sono organizzate attorno a due tratti:

  • Read
  • Write
Suor n Tratto e descrizione Esempio
1

Read

I tipi che implementano la lettura hanno metodi per l'input orientato ai byte. Si chiamano lettori

 Stdin, File
2

Write

I tipi che implementano la scrittura supportano l'output di testo sia orientato ai byte che UTF-8. Si chiamano scrittori.

 Stdout, File

Leggi tratto

Readerssono componenti da cui il programma può leggere byte. Gli esempi includono la lettura di input dalla tastiera, file, eccread_line() Il metodo di questo tratto può essere utilizzato per leggere i dati, una riga alla volta, da un file o da un flusso di input standard.

Suor n Tratto Metodo e descrizione
1 Leggere

read_line(&mut line)->Result

Legge una riga di testo e la aggiunge alla riga, che è una stringa. Il valore restituito è un io :: Result, il numero di byte letti.

Illustrazione - Lettura dalla console - stdin ()

I programmi Rust potrebbero dover accettare valori dall'utente in fase di esecuzione. L'esempio seguente legge i valori dall'input standard (tastiera) e lo stampa nella console.

fn main(){
   let mut line = String::new();
   println!("Enter your name :");
   let b1 = std::io::stdin().read_line(&mut line).unwrap();
   println!("Hello , {}", line);
   println!("no of bytes read , {}", b1);
}

La funzione stdin () restituisce un handle al flusso di input standard del processo corrente, a cui può essere applicata la funzione read_line . Questa funzione cerca di leggere tutti i caratteri presenti nel buffer di input quando incontra un carattere di fine riga.

Produzione

Enter your name :
Mohtashim
Hello , Mohtashim
no of bytes read , 10

Scrivi tratto

Writerssono componenti in cui il tuo programma può scrivere byte. Gli esempi includono la stampa di valori sulla console, la scrittura su file, ecc. Il metodo write () di questa caratteristica può essere utilizzato per scrivere dati in un file o in un flusso di output standard.

Suor n Tratto Metodo e descrizione
1 Scrivi

write(&buf)->Result

Scrive alcuni dei byte nella slice buf nel flusso sottostante. Restituisce un io :: Result, il numero di byte scritti.

Illustrazione - Scrittura sulla console - stdout ()

La stampa! o println! le macro possono essere utilizzate per visualizzare il testo sulla console. Tuttavia, è anche possibile utilizzare la funzione della libreria standard write () per visualizzare del testo nell'output standard.

Consideriamo un esempio per capirlo.

use std::io::Write;
fn main() {
   let b1 = std::io::stdout().write("Tutorials ".as_bytes()).unwrap();
   let b2 = std::io::stdout().write(String::from("Point").as_bytes()).unwrap();
   std::io::stdout().write(format!("\nbytes written {}",(b1+b2)).as_bytes()).unwrap();
}

Produzione

Tutorials Point
bytes written 15

La funzione di libreria standard stdout () restituisce un handle al flusso di output standard del processo corrente, a cui il filewritepuò essere applicata. Il metodo write () restituisce un'enumerazione, Result. Il unfrap () è un metodo di supporto per estrarre il risultato effettivo dall'enumerazione. Il metodo di scartare invierà il panico se si verifica un errore.

NOTE - File IO è discusso nel prossimo capitolo.

Argomenti CommandLine

Gli argomenti CommandLine vengono passati a un programma prima di eseguirlo. Sono come i parametri passati alle funzioni. I parametri CommandLine possono essere utilizzati per passare valori alla funzione main () . Ilstd::env::args() restituisce gli argomenti della riga di comando.

Illustrazione

L'esempio seguente passa i valori come argomenti commandLine alla funzione main (). Il programma è stato creato in un nome di file main.rs .

//main.rs
fn main(){
   let cmd_line = std::env::args();
   println!("No of elements in arguments is :{}",cmd_line.len()); 
   //print total number of values passed
   for arg in cmd_line {
      println!("[{}]",arg); //print all values passed 
      as commandline arguments
   }
}

Il programma genererà un file main.exe una volta compilato. Più parametri della riga di comando devono essere separati da uno spazio. Esegui main.exe dal terminale come main.exe hello tutorialspoint .

NOTE- hello e tutorialspoint sono argomenti della riga di comando.

Produzione

No of elements in arguments is :3
[main.exe]
[hello]
[tutorialspoint]

L'output mostra 3 argomenti poiché main.exe è il primo argomento.

Illustrazione

Il seguente programma calcola la somma dei valori passati come argomenti della riga di comando. Un elenco di valori interi separati da uno spazio viene passato al programma.

fn main(){
   let cmd_line = std::env::args();
   println!("No of elements in arguments is 
   :{}",cmd_line.len()); 
   // total number of elements passed

   let mut sum = 0;
   let mut has_read_first_arg = false;

   //iterate through all the arguments and calculate their sum

   for arg in cmd_line {
      if has_read_first_arg { //skip the first argument since it is the exe file name
         sum += arg.parse::<i32>().unwrap();
      }
      has_read_first_arg = true; 
      // set the flag to true to calculate sum for the subsequent arguments.
   }
   println!("sum is {}",sum);
}

Eseguendo il programma come main.exe 1 2 3 4, l'output sarà -

No of elements in arguments is :5
sum is 10