Rust - Entrada / Salida de archivos

Además de leer y escribir en la consola, Rust permite leer y escribir en archivos.

La estructura File representa un archivo. Permite que un programa realice operaciones de lectura y escritura en un archivo. Todos los métodos de la estructura File devuelven una variante de la enumeración io :: Result.

Los métodos más utilizados de la estructura File se enumeran en la siguiente tabla:

No Señor	Módulo	Método	Firma	Descripción
1	std :: fs :: Archivo	abierto()	pub fn open <P: AsRef> (ruta: P) -> Resultado	El método estático abierto se puede utilizar para abrir un archivo en modo de solo lectura.
2	std :: fs :: Archivo	crear()	pub fn crear <P: AsRef> (ruta: P) -> Resultado	El método estático abre un archivo en modo de solo escritura. Si el archivo ya existía, el contenido antiguo se destruye. De lo contrario, se crea un nuevo archivo.
3	std :: fs :: remove_file	Remover archivo()	pub fn remove_file <P: AsRef> (ruta: P) -> Resultado <()>	Elimina un archivo del sistema de archivos. No hay garantía de que el archivo se elimine inmediatamente.
4	std :: fs :: OpenOptions	adjuntar()	pub fn append (& mut self, append: bool) -> & mut OpenOptions	Establece la opción para el modo de archivo adjunto.
5	std :: io :: Escribe	write_all ()	fn write_all (& mut self, buf: & [u8]) -> Resultado <()>	Intenta escribir un búfer completo en esta escritura.
6	std :: io :: Leer	read_to_string ()	fn read_to_string (& mut self, buf: & mut String) -> Resultado	Lee todos los bytes hasta EOF en esta fuente, agregándolos a buf.

Escribir en un archivo

Veamos un ejemplo para entender cómo escribir un archivo.

El siguiente programa crea un archivo 'data.txt'. El método create () se utiliza para crear un archivo. El método devuelve un identificador de archivo si el archivo se crea correctamente. La última línea de la función write_all escribirá bytes en el archivo recién creado. Si alguna de las operaciones falla, la función wait () devuelve un mensaje de error.

use std::io::Write;
fn main() {
   let mut file = std::fs::File::create("data.txt").expect("create failed");
   file.write_all("Hello World".as_bytes()).expect("write failed");
   file.write_all("\nTutorialsPoint".as_bytes()).expect("write failed");
   println!("data written to file" );
}

Salida

data written to file

Leer de un archivo

El siguiente programa lee el contenido en un archivo data.txt y lo imprime en la consola. La función "abrir" se utiliza para abrir un archivo existente. Una ruta absoluta o relativa al archivo se pasa a la función open () como parámetro. La función open () genera una excepción si el archivo no existe o si no es accesible por cualquier motivo. Si tiene éxito, se asigna un identificador de archivo a dicho archivo a la variable "archivo".

La función "read_to_string" del identificador "file" se usa para leer el contenido de ese archivo en una variable de cadena.

use std::io::Read;

fn main(){
   let mut file = std::fs::File::open("data.txt").unwrap();
   let mut contents = String::new();
   file.read_to_string(&mut contents).unwrap();
   print!("{}", contents);
}

Salida

Hello World
TutorialsPoint

Eliminar un archivo

El siguiente ejemplo usa la función remove_file () para eliminar un archivo. La función wait () devuelve un mensaje personalizado en caso de que ocurra un error.

use std::fs;
fn main() {
   fs::remove_file("data.txt").expect("could not remove file");
   println!("file is removed");
}

Salida

file is removed

Agregar datos a un archivo

La función append () escribe datos al final del archivo. Esto se muestra en el ejemplo que se muestra a continuación:

use std::fs::OpenOptions;
use std::io::Write;

fn main() {
   let mut file = OpenOptions::new().append(true).open("data.txt").expect(
      "cannot open file");
   file.write_all("Hello World".as_bytes()).expect("write failed");
   file.write_all("\nTutorialsPoint".as_bytes()).expect("write failed");
   println!("file append success");
}

Salida

file append success

Copiar un archivo

El siguiente ejemplo copia el contenido de un archivo en un archivo nuevo.

use std::io::Read;
use std::io::Write;

fn main() {
   let mut command_line: std::env::Args = std::env::args();
   command_line.next().unwrap();
   // skip the executable file name
   // accept the source file
   let source = command_line.next().unwrap();
   // accept the destination file
   let destination = command_line.next().unwrap();
   let mut file_in = std::fs::File::open(source).unwrap();
   let mut file_out = std::fs::File::create(destination).unwrap();
   let mut buffer = [0u8; 4096];
   loop {
      let nbytes = file_in.read(&mut buffer).unwrap();
      file_out.write(&buffer[..nbytes]).unwrap();
      if nbytes < buffer.len() { break; }
   }
}

Ejecute el programa anterior como main.exe data.txt datacopy.txt . Se pasan dos argumentos de línea de comando mientras se ejecuta el archivo:

la ruta al archivo fuente
el archivo de destino

↰ Previous page Next page ↱