Óxido - Entrada Salida

Este capítulo describe cómo aceptar valores de la entrada estándar (teclado) y mostrar valores en la salida estándar (consola). En este capítulo, también discutiremos cómo pasar argumentos en la línea de comandos.

Tipos de lectores y escritores

Las funciones de la biblioteca estándar de Rust para entrada y salida se organizan en torno a dos características:

Read
Write

No Señor	Rasgo y descripción	Ejemplo
1	Read Los tipos que implementan Read tienen métodos para la entrada orientada a bytes. Se llaman lectores	Stdin, Archivo
2	Write Los tipos que implementan escritura admiten tanto la salida de texto orientada a bytes como la salida de texto UTF-8. Se llaman escritores.	Stdout, Archivo

Leer rasgo

Readersson componentes de los que su programa puede leer bytes. Los ejemplos incluyen la lectura de entrada desde el teclado, archivos, etc.read_line() El método de este rasgo se puede utilizar para leer datos, una línea a la vez, desde un archivo o flujo de entrada estándar.

No Señor	Rasgo	Método y descripción
1	Leer	read_line(&mut line)->Result Lee una línea de texto y la agrega a la línea, que es una cadena. El valor de retorno es un io :: Result, el número de bytes leídos.

Ilustración - Lectura desde la consola - stdin ()

Es posible que los programas de Rust tengan que aceptar valores del usuario en tiempo de ejecución. El siguiente ejemplo lee valores de la entrada estándar (teclado) y los imprime en la consola.

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 función stdin () devuelve un identificador al flujo de entrada estándar del proceso actual, al que se puede aplicar la función read_line . Esta función intenta leer todos los caracteres presentes en el búfer de entrada cuando encuentra un carácter de final de línea.

Salida

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

Escribir rasgo

Writersson componentes en los que su programa puede escribir bytes. Los ejemplos incluyen imprimir valores en la consola, escribir en archivos, etc. El método write () de este rasgo se puede usar para escribir datos en un archivo o flujo de salida estándar.

No Señor	Rasgo	Método y descripción
1	Escribir	write(&buf)->Result Escribe algunos de los bytes del segmento buf en la secuencia subyacente. Devuelve un io :: Result, el número de bytes escritos.

Ilustración - Escritura en la consola - stdout ()

¡La impresión! o println! Las macros se pueden utilizar para mostrar texto en la consola. Sin embargo, también puede utilizar la función de biblioteca estándar write () para mostrar algo de texto en la salida estándar.

Consideremos un ejemplo para entender esto.

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

Salida

Tutorials Point
bytes written 15

La función de biblioteca estándar stdout () devuelve un identificador al flujo de salida estándar del proceso actual, al quewritese puede aplicar la función. El método write () devuelve una enumeración, Result. El desenvolver () es un método auxiliar para extraer el resultado real de la enumeración. El método de desenvolver enviará pánico si ocurre un error.

NOTE - File IO se trata en el siguiente capítulo.

Argumentos de CommandLine

Los argumentos de CommandLine se pasan a un programa antes de ejecutarlo. Son como parámetros pasados a funciones. Los parámetros de CommandLine se pueden usar para pasar valores a la función main () . losstd::env::args() devuelve los argumentos de la línea de comandos.

Ilustración

El siguiente ejemplo pasa valores como argumentos commandLine a la función main (). El programa se crea en un nombre de archivo 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
   }
}

El programa generará un archivo main.exe una vez compilado. Los parámetros de la línea de comandos múltiples deben estar separados por un espacio. Ejecute main.exe desde la terminal como main.exe hello tutorialspoint .

NOTE- hello y tutorialspoint son argumentos de línea de comandos.

Salida

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

La salida muestra 3 argumentos ya que main.exe es el primer argumento.

Ilustración

El siguiente programa calcula la suma de los valores pasados como argumentos de la línea de comandos. Se pasa al programa una lista de valores enteros separados por espacios.

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

Al ejecutar el programa como main.exe 1 2 3 4, la salida será:

No of elements in arguments is :5
sum is 10

↰ Previous page Next page ↱