Las variables mutables e inmutables en Rust

En este capítulo te mostraré una introducción al uso de las variables mutables e inmutables en Rust.

Declaración de Variables en Rust

Para declarar una variable en Rust, utilizamos la palabra clave let.

Por defecto, las variables en Rust son inmutables, lo que significa que una vez asignado un valor, no se puede cambiar. Aunque podrías decir entonces que son constantes, no exactamente. Hay algunas diferencias entre variable inmutable y constante.

Esto es bueno, ya que nos fuerza a tener de primeras (por defecto) todos los contenedores con valores fijos, y si se necesita reasignar una variable, lo indicaremos explícitamente. Esto da mayor robustez y seguridad al código. Nos va a evitar muchas incongruencias en el futuro.

fn main() {
    let a = 10;
}

La variable se declara con let, le damos un nombre o identificador y asignamos un dato con el operador de asignación (=).

Convención de nomenclatura para variables en Rust

• Se utilizan minúsculas y snake_case para los nombres de variables.
• Los nombres deben ser descriptivos y reflejar claramente el propósito de la variable.
• Se pueden utilizar guiones bajos para separar palabras en nombres compuestos.
• Se desaconseja el uso de abreviaturas o siglas que no sean ampliamente conocidas.
• Puedes usar números en los nombres de las variables, pero no al principio. Por ejemplo, variable1 es válido, pero 1variable no lo es.
• No puedes usar espacios en blanco en los nombres de las variables. Sin embargo, puedes usar guiones bajos _ para separar palabras si lo deseas.
• En general, se desaconseja el uso de símbolos del teclado en los nombres de las variables. La mayoría de los símbolos no son permitidos en los nombres de variables en Rust. Sin embargo, puedes usar guiones bajos _ como se mencionó anteriormente.

En muchos de los ejemplos de este curso, con tal de simplificarlos, utilizaré nombres de variable como "a" o "b". Estos nombres no son muy descriptivos para programas completos, pero si que ayudan a resolver problemas de lógica cuando estás estudiando.

Llamar a una variable

Las variables en Rust se llaman de la misma forma que esperaríamos en casi cualquier lenguaje de programación. Sin embargo, tendremos que atender a alguna peculiaridad de los macros, que trataré en otro capítulo. Por el momento, si intentas llamar así, te va a dar un error de compilación:

fn main() {
    let a = 10;
    println!(a);
}

error: format argument must be a string literal
 --> src\main.rs:3:14
  |
3 |     println!(a);
  |              ^
  |
help: you might be missing a string literal to format with
  |
3 |     println!("{}", a);
  |              +++++

El error indica que no se puede llamar a la variable directamente en la macro println!(). Después, nos da una ayuda: "es posible que le falte un literal de cadena para formatear".

println!() requiere comenzar con un argumento literal de tipo string (cadena de caracteres). Entonces, podemos hacer esto:

fn main() {
    let a = 10;
    println!("{}", a);
}

10

Las llaves colocan el valor de la variable en el string. De esa forma se hace posible imprimir el valor numérico en la cadena. Si no las pones, te aparecerá este error:

fn main() {
    let a = 10;
    println!("", a);
}

error: argument never used
 --> src\main.rs:3:18
  |
3 |     println!("", a);
  |              --  ^ argument never used
  |              |
  |              formatting specifier missing

El error indica que nos falta un especificador de formateo, y que el argumento que llama a la variable a, nunca se utiliza.

En lugar de dejar el string vacío, con solo el especificador, puedes poner algo de texto:

fn main() {
    let a = 10;
    println!("El valor de la variable es: {}", a);
}

El valor de la variable es: 10

Variables mutables en Rust

Las variables, tal y como he indicado son inmutables por defecto. Si intentas reasignarlas, tendrás un error:

fn main() {
    let a = 10;
    println!("El valor de la variable es: {}", a);

    a = 30;
    println!("El valor de la variable es: {}", a);
}

error[E0384]: cannot assign twice to immutable variable `a`
 --> src\main.rs:5:5
  |
2 |     let a = 10;
  |         -
  |         |
  |         first assignment to `a`
  |         help: consider making this binding mutable: `mut a`
...
5 |     a = 30;
  |     ^^^^^^ cannot assign twice to immutable variable

El error indica que no se puede asignar dos veces a la variable inmutable.

Si necesitas utilizar las variables de forma mutable, es decir, que puedan ser reasignadas, añadiremos la palabra clave mut de "mutable" en la declaración:

fn main() {
    let mut a = 10;
    println!("El valor de la variable es: {}", a);

    a = 30;
    println!("El valor de la variable es: {}", a);
}

El valor de la variable es: 10
El valor de la variable es: 30