Variables y Mutabilidad - Tylung/rust-apuntes GitHub Wiki

Variables en Rust

Las variables en rust por defecto son inmutables esto lo hace rust para impulsar la seguridad del código y facilitar la concurrencia. Las variables se declaran con la palabra reservada let

Cuando una variable es inmutable, una vez que un valor está vinculado a un nombre, no puede cambiar ese valor

fn main() {
    let saludo = "Hola!";
    println!("{}", saludo);
    saludo = "Adios!"; ❌
    println!("{}", saludo);
}

El código anterior daría error porque no se le puede modificar el valor a la variable saludo.

fn main() {
    let mut numero = 3;
    println!("{}", numero);
    numero = 10; 
    println!("{}", numero);
}

Para indicarle que la variable va a cambiar se le pone antes la palabra reservada mut

Constantes en Rust

Al igual que las variables inmutables, las constantes son valores que están vinculados a un nombre y no se les permite cambiar, pero existen algunas diferencias entre las constantes y las variables.

Primero, no está permitido usar mut con constantes. Las constantes no solo son inmutables de forma predeterminada, siempre son inmutables. Declaras constantes usando la palabra clave const en lugar de la palabra clave let, y el tipo del valor debe anotarse

Las constantes se pueden declarar en cualquier ámbito, incluido el ámbito global, lo que las hace útiles para valores que muchas partes del código necesitan conocer. La última diferencia es que las constantes se pueden establecer solo en una expresión constante, no como resultado de un valor que solo se puede calcular en tiempo de ejecución.

const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;

El nombre de la constante es TRES_HORAS_EN_SEGUNDOS y su valor se establece en el resultado de multiplicar 60 (la cantidad de segundos en un minuto) por 60 (la cantidad de minutos en una hora) por 3 (la cantidad de horas que queremos contar en este programa ). La convención de nomenclatura de Rust para constantes es usar mayúsculas con guiones bajos entre palabras. El compilador puede evaluar un conjunto limitado de operaciones en tiempo de compilación, lo que nos permite elegir escribir este valor de una manera que sea más fácil de entender y verificar, en lugar de establecer esta constante en el valor 10,800.

Shadowing in Rust

El shadowing es una manera de sobreescribir el valor de una variable, sin la necesidad de poner mut, se dice que le hace un shadow a la variable o la ensombrese para que sea el ultimo valor que lea el compilador de Rust.

El shadowing se logra anteponiendo el nombre de la variable y su valor de la parabra reservada let, con lo que creara otra nueva variable con el mismo nombre, sobreescribiendo el valor anterior

En el guessing game se utilizo el shadowing para convertir el valor de el numero elegido del usuario de un string a un numero y poder compararlo con el numero secreto y si no recibe un numero le dara un error al usuario donde le pedira que tipee un numero

    print!("Ingresa el numero: ");
    let mut num_elegido = String::new();

    io::stdin()
        .read_line(&mut num_elegido)
        .expect("Fallo al leer el prompt" );

    let num_elegido: u32 = num_elegido.trim().parse().expect("Please type a number!");

Otro ejemplo de shadowing:

fn main() {
    let x = 5;

    let x = x + 1;

    {
        let x = x * 2;
        println!("The value of x in the inner scope is: {x}");
    }

    println!("The value of x is: {x}");
}

Las salida de este ejemplo será la siguiente:

$ cargo run
   Compiling variables v0.1.0 (file:///projects/variables)
    Finished dev [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/variables`
The value of x in the inner scope is: 12
The value of x is: 6