viernes, 12 de abril de 2019

Creando videojuegos en Rust lang (Parte 18)

Programa 12. "pre_hello_ggez12" Manejando variables que pueden ser vacías: "Option"
En lenguajes de programación como C, C++ o Java tenemos situaciones donde se anula una referencia o no hay valor que podamos regresar así que regresamos "null" (un valor nulo). En cambio en Rust no existe "null" y en su lugar se sugiere usar un enum llamado "Option". Este enum de "Option" viene incluido en la librería predeterminada de Rust así que lo podemos usar sin definirlo.

El enum "Option" hace uso de valores genéricos. Los genéricos también funcionan con "enum", de forma similar a los "structs". La definición de Option es la siguiente, hay que notar que usa un valor genérico "<T>" :

1
2
3
4
enum Option<T> {
    None,
    Some(T)
}

La definición anterior nos permite asignar "None" en el caso que no haya valor o resultado. De otra forma asignamos "Some" y ponemos entre el paréntesis la variable que obtenemos. Así podemos manejar datos que pueden no tener valor. Simplemente hay que envolverlos en una Option.

Para obtener el valor interno podemos considerar 4 opciones:
  • Usar una instrucción "match" y obtener de ahí el valor que necesitamos. De esta forma también podemos manejar el comportamiento cuando el valor este vacío ("None").
  • Usar el método de Option llamado "unwrap()". Unwrap ("desenvolver" en inglés) hace lo que su nombre dice, regresa el valor sin en envoltorio de "Option". Su desventaja es que si no hay valor entonces entra en pánico y detiene la ejecución del programa.
  • Usar el método de Option llamado "unwrap_or(default)". Similar a unwrap, con la diferencia de que si es None entonces regresa el valor especificado como el "default. Así se evita que detenga la ejecución ya que proporciona el valor default en caso que este como "None".
  • Usar el método de Option llamado "expect("mi mensaje de error")". El método "expect" regresa el valor interno del Option si lo hay y si no lo hay detiene la ejecución y muestra el mensaje personalizado de configuraste, es decir en el caso anterior mostraría "mi mensaje de error".
Las manipulaciones descritas anteriormente se muestran en el código siguiente donde usamos la división entre cero como ejemplo de una situación donde podemos usar "Option" y manejarlo:


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
fn checar_division(dividendo: i32, divisor: i32) -> Option<i32> {
    if divisor == 0 {
        None
    } else {
        Some(dividendo/divisor)
    }
}

fn checar_opcion(entrada: Option<String>) {
    match entrada {
        Option::None => println!("Esta vacío"),
        Option::Some(value) => println!("Tiene un valor, y el valor es {}",
                                        value)
    }
}

fn checar_cociente(input: Option<i32>) {
    match input {
        Option::None => println!("Falló la divisón"),
        Option::Some(cociente) => println!("Calculado, el cociente es {}",
                                            cociente)
    }
}

fn main() {
    let op1: Option<String> = Option::None;
    let op2: Option<String> = Option::Some(String::from("Mi texto"));
    checar_opcion(op1);
    checar_opcion(op2);
    let op3 = checar_division(6, 3);
    let op4 = checar_division(4, 0);
    println!("op3: {:?}", op3);
    println!("op4: {:?}", op4);
    println!("op3.unwrap(): {:?}", op3.unwrap());
    // No ejecutamos op4.unwrap() porque detendría la ejecución
    checar_cociente(op3);
    checar_cociente(op4);
    println!("op3.unwrap_or(0): {:?}", op3.unwrap_or(0));
    println!("op4.unwrap_or(0): {:?}", op4.unwrap_or(0));
    println!("op3 usando expect: {:?}", op3.expect("Division entre cero"));
    println!("op4 usando expect: {:?}", op4.expect("Division entre cero"));
}

El resultado de correr el programa es el siguiente:

Podemos ver que se detuvo la ejecución en el "expect" y que imprimió nuestro mensaje personalizado.

Navegación:
Primera parte
Siguiente parte
Parte anterior

Fuente (inglés):
Publicadas por a la/s

No hay comentarios.:

Publicar un comentario

Suscribirse a: Comentarios de la entrada (Atom)