Ferrugem - Entrada Saída

Este capítulo discute como aceitar valores da entrada padrão (teclado) e exibir valores para a saída padrão (console). Neste capítulo, também discutiremos a passagem de argumentos de linha de comando.

Tipos de leitor e escritor

Os recursos de biblioteca padrão do Rust para entrada e saída são organizados em torno de duas características -

Read
Write

Sr. Não	Traço e descrição	Exemplo
1	Read Os tipos que implementam Read possuem métodos para entrada orientada a bytes. São chamados de leitores	Stdin, Arquivo
2	Write Tipos que implementam Write suportam saída de texto orientada a bytes e UTF-8. Eles são chamados de escritores.	Stdout, Arquivo

Ler Traço

Readerssão componentes dos quais seu programa pode ler bytes. Os exemplos incluem a leitura de entrada do teclado, arquivos, etc.read_line() O método desse traço pode ser usado para ler dados, uma linha por vez, de um arquivo ou fluxo de entrada padrão.

Sr. Não	Traço	Método e Descrição
1	Ler	read_line(&mut line)->Result Lê uma linha de texto e a anexa à linha, que é uma String. O valor de retorno é um io :: Result, o número de bytes lidos.

Ilustração - Leitura do console - stdin ()

Os programas Rust podem ter que aceitar valores do usuário em tempo de execução. O exemplo a seguir lê os valores da entrada padrão (teclado) e os imprime no 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);
}

A função stdin () retorna um identificador para o fluxo de entrada padrão do processo atual, ao qual a função read_line pode ser aplicada. Esta função tenta ler todos os caracteres presentes no buffer de entrada quando encontra um caractere de fim de linha.

Resultado

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

Traço de escrita

Writerssão componentes nos quais seu programa pode gravar bytes. Os exemplos incluem a impressão de valores no console, gravação em arquivos, etc. O método write () desta característica pode ser usado para gravar dados em um arquivo ou fluxo de saída padrão.

Sr. Não	Traço	Método e Descrição
1	Escreva	write(&buf)->Result Grava alguns dos bytes no buffer de fatia no fluxo subjacente. Ele retorna um io :: Result, o número de bytes gravados.

Ilustração - Escrevendo para o console - stdout ()

A impressão! ou println! macros podem ser usadas para exibir texto no console. No entanto, você também pode usar a função de biblioteca padrão write () para exibir algum texto na saída padrão.

Vamos considerar um exemplo para entender isso.

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

Resultado

Tutorials Point
bytes written 15

A função de biblioteca padrão stdout () retorna um identificador para o fluxo de saída padrão do processo atual, para o qual owritefunção pode ser aplicada. O método write () retorna um enum, Result. O unbrap () é um método auxiliar para extrair o resultado real da enumeração. O método de desempacotamento enviará pânico se ocorrer um erro.

NOTE - O arquivo IO é discutido no próximo capítulo.

Argumentos CommandLine

Os argumentos da CommandLine são passados para um programa antes de executá-lo. Eles são como parâmetros passados para funções. Os parâmetros CommandLine podem ser usados para passar valores para a função main () . ostd::env::args() retorna os argumentos da linha de comando.

Ilustração

O exemplo a seguir passa valores como argumentos commandLine para a função main (). O programa é criado em um nome de arquivo 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
   }
}

O programa irá gerar um arquivo main.exe uma vez compilado. Vários parâmetros de linha de comando devem ser separados por espaço. Execute main.exe a partir do terminal como main.exe hello tutorialspoint .

NOTE- hello e tutorialspoint são argumentos de linha de comando.

Resultado

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

A saída mostra 3 argumentos, já que main.exe é o primeiro argumento.

Ilustração

O programa a seguir calcula a soma dos valores passados como argumentos de linha de comando. Uma lista de valores inteiros separados por espaço é passada ao programa.

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

Ao executar o programa como main.exe 1 2 3 4, a saída será -

No of elements in arguments is :5
sum is 10

↰ Previous page Next page ↱