Rust Archivos y IO
Este capítulo presenta las operaciones de E/S del lenguaje Rust.
Recibir argumentos de línea de comandos
Los programas de línea de comandos son la forma más básica de existencia de los programas informáticos. Casi todos los sistemas operativos admiten programas de línea de comandos y basan la ejecución de programas visuales en el mecanismo de línea de comandos.
Un programa de línea de comandos debe poder recibir argumentos del entorno de línea de comandos. Estos argumentos suelen estar separados por espacios después de un comando de línea de comandos.
En muchos lenguajes (como Java y C/C++), los argumentos del entorno se pasan al programa como parámetros de la función principal (a menudo un array de cadenas). Pero en Rust, la función principal es una función sin parámetros; los argumentos del entorno deben ser obtenidos por el desarrollador a través del módulo std::env. El proceso es muy sencillo:
Ejemplo
let args = std::env::args();
println!("{:?}", args);
}
Ahora ejecuta el programa directamente:
Args { inner: ["D:\\rust\\greeting\\target\\debug\\greeting.exe"] }Tal vez el resultado que obtengas sea mucho más largo que esto, es normal. En este resultado, la estructura Args tiene un array 'inner' que contiene una única cadena, la cual representa la ubicación del programa que se está ejecutando actualmente.
Pero esta estructura de datos es difícil de entender. No importa, podemos simplemente iterar sobre ella:
Ejemplo
let args = std::env::args();
for arg in args {
println!("{}", arg);
}
}
Resultado de la ejecución:
D:\rust\greeting\target\debug\greeting.exe
Los argumentos generalmente existen para ser iterados, ¿no es así?
Ahora abramos el launch.json que no hemos tocado en mucho tiempo, busquemos "args": [], aquí se pueden configurar los argumentos en tiempo de ejecución. Lo cambiaremos a "args": ["first", "second"], luego guardamos, ejecutamos el programa anterior nuevamente. Resultado de la ejecución:
D:\rust\greeting\target\debug\greeting.exe first second
Como un verdadero programa de línea de comandos, nunca lo hemos utilizado realmente. Como tutorial de lenguaje, no explicaremos aquí cómo ejecutar programas Rust mediante la línea de comandos. Pero si eres un desarrollador bien entrenado, deberías poder encontrar la ubicación del archivo ejecutable; puedes intentar entrar en el directorio y usar comandos de línea de comandos para probar que el programa reciba argumentos del entorno de línea de comandos.
Entrada de línea de comandos
Los capítulos anteriores explicaron detalladamente cómo usar la salida de línea de comandos. Esto se debe a las necesidades del aprendizaje del lenguaje; sin salida es imposible depurar programas. Sin embargo, obtener información de entrada desde la línea de comandos sigue siendo muy importante para un programa de línea de comandos.
En Rust, el módulo std::io proporciona funcionalidades relacionadas con la entrada estándar (que puede considerarse como entrada de línea de comandos):
Ejemplo
fn main() {
let mut str_buf = String::new();
stdin().read_line(&mut str_buf)
.expect("Failed to read line.");
println!("Your input line is \n{}", str_buf);
}
Hacer que el entorno de VSCode admita la entrada de línea de comandos es algo muy engorroso, ya que involucra problemas de incompatibilidad entre plataformas y problemas de no poder depurar. Por lo tanto, ejecutamos el programa directamente en la terminal de VSCode. En la línea de comandos ejecuta:
D:\rust\greeting> cd ./target/debug D:\rust\greeting\target\debug> ./greeting.exe EJEMPLO Your input line is EJEMPLO
std::io::Stdio incluye el método de lectura read_line, que puede leer una línea de cadena en un búfer. El valor de retorno es una enumeración Result, utilizada para transmitir errores que ocurren durante la lectura. Por eso se suelen usar las funciones expect o unwrap para manejar errores.
Nota: Actualmente, la biblioteca estándar de Rust no proporciona un método para leer directamente números o datos formateados desde la línea de comandos. Podemos leer una línea de cadena y usar funciones de reconocimiento de cadenas para procesar los datos.
Lectura de archivos
Creamos un archivo text.txt en el directorio D:\ de la computadora, con el siguiente contenido:
This is a text file.
Este es un programa que lee el contenido de un archivo de texto en una cadena:
Ejemplo
fn main() {
let text = fs::read_to_string("D:\\text.txt").unwrap();
println!("{}", text);
}
Resultado de la ejecución:
This is a text file.
En Rust, leer un archivo completo que quepa en memoria es algo extremadamente sencillo. El método read_to_string del módulo std::fs puede realizar fácilmente la lectura de archivos de texto.
Pero si el archivo a leer es binario, podemos usar la función std::fs::read para leer una colección de tipo u8:
Ejemplo
fn main() {
let content = fs::read("D:\\text.txt").unwrap();
println!("{:?}", content);
}
Resultado de la ejecución:
[84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 116, 101, 120, 116, 32, 102, 105, 108, 101, 46]
Los dos métodos anteriores son de lectura única, muy adecuados para el desarrollo de aplicaciones web. Sin embargo, para algunos programas de bajo nivel, el método tradicional de lectura por flujo sigue siendo insustituible, porque en muchos casos el tamaño del archivo puede superar con creces la capacidad de la memoria.
Método de lectura de archivos por flujo en Rust:
Ejemplo
use std::fs;
fn main() {
let mut buffer = [0u8; 5];
let mut file = fs::File::open("D:\\text.txt").unwrap();
file.read(&mut buffer).unwrap();
println!("{:?}", buffer);
file.read(&mut buffer).unwrap();
println!("{:?}", buffer);
}
Resultado de la ejecución:
[84, 104, 105, 115, 32] [105, 115, 32, 97, 32]
La clase File del módulo std::fs es la clase que describe archivos y se puede usar para abrir archivos. Después de abrir un archivo, podemos usar el método read de File para leer por flujo algunos bytes siguientes del archivo hacia un búfer (el búfer es un array de u8). El número de bytes leídos es igual a la longitud del búfer.
Nota: VSCode actualmente no tiene la función de agregar automáticamente referencias a la biblioteca estándar, por lo que a veces aparecen errores como "la función o el método no existe", que pueden deberse a problemas de referencia de la biblioteca estándar. Podemos consultar la documentación de comentarios de la biblioteca estándar (aparece al pasar el ratón) para agregar manualmente la biblioteca estándar.
El método open de std::fs::File abre el archivo en modo "solo lectura" y no tiene un método close correspondiente, porque el compilador de Rust puede cerrar automáticamente el archivo cuando ya no se usa.
Escritura de archivos
La escritura de archivos se divide en escritura única y escritura por flujo. La escritura por flujo requiere abrir el archivo; las formas de apertura son "crear" (create) y "agregar" (append).
Escritura única:
Ejemplo
fn main() {
fs::write("D:\\text.txt", "FROM RUST PROGRAM")
.unwrap();
}
Esto es tan simple y conveniente como la lectura única. Después de ejecutar el programa, el contenido del archivo D:\text.txt será reescrito como FROM RUST PROGRAM. Por lo tanto, ¡usa la escritura única con precaución! Porque eliminará directamente el contenido del archivo (sin importar cuán grande sea el archivo). Si el archivo no existe, lo creará.
Si deseas escribir el contenido del archivo usando el modo de flujo, puedes usar el método create de std::fs::File:
Ejemplo
use std::fs::File;
fn main() {
let mut file = File::create("D:\\text.txt").unwrap();
file.write(b"FROM RUST PROGRAM").unwrap();
}
Este programa es equivalente al programa anterior.
Nota: El archivo abierto debe almacenarse en una variable mutable para poder usar los métodos de File.
En la clase File no existe un método estático append, pero podemos usar OpenOptions para abrir archivos con un método específico:
Ejemplo
use std::fs::OpenOptions;
fn main() -> std::io::Result<()> {
let mut file = OpenOptions::new()
.append(true).open("D:\\text.txt")?;
file.write(b" APPEND WORD")?;
Ok(())
}
Después de ejecutar, el contenido del archivo D:\text.txt se convertirá en:
FROM RUST PROGRAM APPEND WORD
OpenOptions es un método flexible para abrir archivos; permite configurar permisos de apertura. Además del permiso append, también existen los permisos read y write. Si queremos abrir un archivo con permisos de lectura y escritura, podemos escribir así:
Ejemplo
use std::io::prelude::*;
use std::fs::OpenOptions;
fn main() -> std::io::Result<()> {
let mut file = OpenOptions::new()
.read(true).write(true).open("D:\\text.txt")?;
file.write(b"COVER")?;
Ok(())
}
Después de ejecutar, el contenido del archivo D:\text.txt se convertirá en:
COVERRUST PROGRAM APPEND WORDOtras extensiones