Rouille - Entrée Sortie

Ce chapitre explique comment accepter les valeurs de l'entrée standard (clavier) et afficher les valeurs vers la sortie standard (console). Dans ce chapitre, nous aborderons également le passage des arguments de ligne de commande.

Types de lecteurs et d'écrivains

Les fonctionnalités de bibliothèque standard de Rust pour l'entrée et la sortie sont organisées autour de deux traits -

• Read
• Write

Sr. Non	Trait et description	Exemple
1	Read Les types qui implémentent Read ont des méthodes pour l'entrée orientée octet. Ils sont appelés lecteurs	Stdin, fichier
2	Write Les types qui implémentent Write prennent en charge la sortie de texte orientée octet et UTF-8. Ils sont appelés écrivains.	Stdout, fichier

Lire le trait

Readerssont des composants à partir desquels votre programme peut lire des octets. Les exemples incluent la lecture des entrées du clavier, des fichiers, etc.read_line() La méthode de cette caractéristique peut être utilisée pour lire des données, une ligne à la fois, à partir d'un fichier ou d'un flux d'entrée standard.

Sr. Non	Trait	Méthode et description
1	Lis	read_line(&mut line)->Result Lit une ligne de texte et l'ajoute à la ligne, qui est une chaîne. La valeur de retour est un io :: Result, le nombre d'octets lus.

Illustration - Lecture depuis la console - stdin ()

Les programmes Rust devront peut-être accepter des valeurs de l'utilisateur lors de l'exécution. L'exemple suivant lit les valeurs de l'entrée standard (clavier) et les imprime sur la 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 fonction stdin () renvoie un handle vers le flux d'entrée standard du processus actuel, auquel la fonction read_line peut être appliquée. Cette fonction essaie de lire tous les caractères présents dans le tampon d'entrée lorsqu'elle rencontre un caractère de fin de ligne.

Production

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

Écrire un trait

Writerssont des composants sur lesquels votre programme peut écrire des octets. Les exemples incluent l'impression de valeurs sur la console, l'écriture dans des fichiers, etc. La méthode write () de ce trait peut être utilisée pour écrire des données dans un fichier ou un flux de sortie standard.

Sr. Non	Trait	Méthode et description
1	Écrire	write(&buf)->Result Écrit certains des octets de la tranche buf dans le flux sous-jacent. Il renvoie un io :: Result, le nombre d'octets écrits.

Illustration - Ecrire sur la console - stdout ()

L' impression! ou println! Les macros peuvent être utilisées pour afficher du texte sur la console. Cependant, vous pouvez également utiliser la fonction de bibliothèque standard write () pour afficher du texte sur la sortie standard.

Prenons un exemple pour comprendre cela.

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

Production

Tutorials Point
bytes written 15

La fonction de bibliothèque standard stdout () renvoie un handle vers le flux de sortie standard du processus courant, auquel lewritela fonction peut être appliquée. La méthode write () renvoie une énumération, Result. Unrap () est une méthode d'aide pour extraire le résultat réel de l'énumération. La méthode de dépliage enverra la panique si une erreur se produit.

NOTE - Les E / S de fichier sont traitées dans le chapitre suivant.

Arguments de la ligne de commande

Les arguments CommandLine sont transmis à un programme avant de l'exécuter. Ce sont comme des paramètres passés aux fonctions. Les paramètres CommandLine peuvent être utilisés pour transmettre des valeurs à la fonction main () . lestd::env::args() renvoie les arguments de la ligne de commande.

Illustration

L'exemple suivant transmet des valeurs en tant qu'arguments commandLine à la fonction main (). Le programme est créé dans un nom de fichier 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
   }
}

Le programme générera un fichier main.exe une fois compilé. Plusieurs paramètres de ligne de commande doivent être séparés par un espace. Exécutez main.exe depuis le terminal en tant que main.exe bonjour tutorialspoint .

NOTE- hello et tutorialspoint sont des arguments de ligne de commande.

Production

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

La sortie affiche 3 arguments car le main.exe est le premier argument.

Illustration

Le programme suivant calcule la somme des valeurs transmises comme arguments de ligne de commande. Une liste de valeurs entières séparées par un espace est transmise au programme.

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

Lors de l'exécution du programme en tant que main.exe 1 2 3 4, la sortie sera -

No of elements in arguments is :5
sum is 10