Variables y mutabilidad

En Rust, la gestión de variables y memoria se rige por dos principios fundamentales: la seguridad y el control. Por esta razón, a diferencia de muchos otros lenguajes de programación, en Rust las variables son inmutables por defecto.

Esto significa que una vez que se asigna un valor a una variable, este no se puede modificar. Si intentas hacerlo, el compilador generará un error.

Variables Inmutables y la Palabra Clave mut

Para declarar una variable se usa la palabra clave let:

let x = 5; // Immutabile di default
// x = 6; // ERRORE! Il compilatore si rifiuterà di compilare.

Si necesitas cambiar el valor de una variable, debes hacerla explícitamente mutable usando la palabra clave mut justo después de let:

let mut y = 10; // Mutabile
println!("Il valore di y e: {}", y);
y = 15; // Valido!
println!("Il valore modificato di y e: {}", y);

El uso del prefijo mut comunica claramente al compilador y al lector del código que ese valor cambiará en el transcurso de la ejecución.

Shadowing (Sombreado)

Rust también permite el concepto de shadowing (sombreado), es decir, la redeclaración de una variable con el mismo nombre usando nuevamente la palabra clave let. La nueva variable "cubre" (o ensombrece) a la anterior:

let x = 5;
let x = x + 1; // Shadowing: x ora vale 6
let x = x * 2; // Shadowing: x ora vale 12

A diferencia de mut, el shadowing te permite:

1. Cambiar el tipo de dato de una variable manteniendo el mismo nombre.
2. Mantener la inmutabilidad de la variable después de las transformaciones.

let spaces = "   "; // Tipo: &str (stringa)
let spaces = spaces.len(); // Tipo: usize (numero intero)

Utilidad del Shadowing y los Ámbitos (Scopes)

El shadowing no se limita al mismo bloque; se puede utilizar dentro de bloques anidados ({}) para sobrescribir temporalmente un valor. Cuando el bloque interno termina, la variable original vuelve a ser visible:

let x = 5;
{
    let x = x * 2; // Shadowing valido solo all'interno del blocco
    println!("Valore nel blocco interno: {}", x); // Stampa 10
}
println!("Valore nel blocco esterno: {}", x); // Stampa 5

Este mecanismo es extremadamente seguro y eficiente porque ocurre por completo en tiempo de compilación, garantizando la seguridad de tipos sin ningún costo de rendimiento en tiempo de ejecución.

Pruébalo tú