Rust / OpenOptions

Bienvenidos sean a este post, hoy hablaremos sobre este struct.

Este fue utilizado en el post anterior pero hoy veremos la parte teorica, en este caso este creador nos permite tener mas opciones para poder manipular cuales son las operaciones permitidas sobre el archivo, dos alias que se utilizan para las opciones mas comunes son File::open y File::create, por lo general inicialmente usaremos a new para crear un objeto donde pasaremos las opciones sobre el archivo y la ultima opcion sera open donde pasaremos el archivo que utilizaremos, les dejo un ejemplo de creacion de objeto:

let mut archivo = OpenOptions::new().write(true)
					.create(true)
					.open("archivo.txt")
					.unwrap();

Observen como usamos varias opciones antes de open pero el ultimo no es porque finalmente usamos a unwrap por si ocurre algun error y pueda ser manejado, tambien se puede usar a expect, pero sobre estos dos metodos los veremos mas profundamente en otro post, veamos las implementaciones disponibles:

• new(), crea un conjunto en blanco para las opciones que podemos implementar
• read(bool), establece mediante un booleano si puede leer (true) o no (false)
• write(bool), idem al anterior pero para la escritura del archivo
• append(bool), idem a los anteriores pero establece que se pueda agregar mas datos al archivo
• truncate(bool), si se pasa true y se abre exitosamente el archivo esta opcion lo vaciara completamente
• create(bool), si se pasa true este abrira el archivo si existe sino lo creara, si es false no creara el archivo si no existe
• create_new(bool), si se pasa true este creara un nuevo archivo y si existe fallara
• open(path_archivo), este se encargara de abrir el archivo que le pasemos como argumento

Salvo new y open, el resto son completamente opcionales y en caso de no pasarlos se tomaran los valores predeterminados y basicos para poder manipularlos, para entenderlo vamos a crear un ejemplo simple, para ello crearemos un nuevo proyecto que llamaremos abrir_opciones, una vez creado iremos al archivo main.rs y modificaremos el codigo generado con el siguiente:

main.rs

use std::io::{Write, BufReader};
use std::io::prelude::*;
use std::fs::{OpenOptions};

fn main() -> std::io::Result<()>
{
	let mut archivo = OpenOptions::new()
				.write(true)
				.create(true)
				.open("archivo.txt")
				.unwrap();

	let texto = b"tinchicus.com es el mejor lugar para aprender";
	archivo.write_all(texto)?;
	println!("El archivo se genero con exito");

	archivo = OpenOptions::new()
				.read(true)
				.open("archivo.txt")
				.unwrap();

	let mut lector = BufReader::new(archivo);
	let mut cdn_buff = String::new();
	lector.read_line(&mut cdn_buff)?;

	println!("Linea leida: {}", cdn_buff);
	Ok(())
}

Al comienzo llamaremos a todas las librerias que necesitaremos para nuestro codigo, desde las de OpenOptions hasta aquellas necesarias para escribir y leer, en el main le diremos que debe devolver el tipo Result para tener la capacidad de devolver el dato y el error (en caso de ocurrir), veamos el primer bloque que crea la apertura del archivo:

	let mut archivo = OpenOptions::new()
				.write(true)
				.create(true)
				.open("archivo.txt")
				.unwrap();

Observen que establecemos las opciones para poder escribir (write) y crear en caso de que no exista el archivo, luego pasamos el nombre del archivo a manipular, recuerden que unwrap es para devolver un error al Result en caso de ocurrir, lo siguiente sera el texto que escribiremos en el archivo, para despues por medio de write_all escribiremos el texto anterior, si observan tiene un signo de interrogacion al final antes del punto y coma (;), este es un operador especial que trabaja de manera similar al match pero que no hace nada sino ocurre ningun error pero en caso de error genera un error para el Result y sale del metodo, de este operador hablaremos en un post mas adelante, despues notificaremos que se creo el archivo, lo siguiente sera este bloque:

	archivo = OpenOptions::new()
				.read(true)
				.open("archivo.txt")
				.unwrap();

En esta ocasion por medio de new le pasamos el parametro de lectura y volvemos a abrir el archivo anteriormente creado (o modificado), despues crearemos un objeto de BufReader que llamaremos lector, lo siguiente sera crear una variable de tipo String, la cual sera la receptora del uso de la funcion read_line que sera aplicado al objeto lector y pasara todo el contenido a la variable cdn_buff, la ultima linea sera la encargada de mostrar el contenido almancenado en cdn_buff, compilemos y veamos su salida:

tinchicus@dbn001vrt:~/lenguajes/rust/abrir_opciones$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.02s
     Running `target/debug/abrir_opciones`
El archivo se genero con exito
Linea leida: tinchicus.com es el mejor lugar para aprender
tinchicus@dbn001vrt:~/lenguajes/rust/abrir_opciones$

En resumen, hoy hemos visto OpenOptions, que es, como nos ayuda con respecto al Open, las opciones que podemos usar, como es su sintaxis y por ultimo un ejemplo para verlo en accion, espero les haya sido de utilidad sigueme en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.