Immutabilité et Ombrage

Immutabilité par défaut

Une variable est immutable par défaut, c’est-à-dire qu’une fois liée à une valeur, cette dernière ne peut pas être changée:

fn main() {
    let x = 5;
    println!("The value of x is: {x}");
    //x = 6; // Ce code est invalide
    //println!("The value of x is: {x}");
}

Ainsi, pour qu’il soit valide, ce code doit être réécrit ainsi (noter le mot-clef mut):

fn main() {
    let mut x = 5;
    println!("The value of x is: {x}");
    x = 6; // Ce code est valide
    println!("The value of x is: {x}");
}

Ombrage

L’ombrage (shadowing) consiste à lier une nouvelle variable avec le même nom afin de modifier sa valeur:

fn main() {
    let x = 5;
    println!("The value of x is: {x}");
    let x = x + 1;
    println!("The value of x is: {x}");
}

La portée (scope) d’une variable liée est limitée à son bloc de définition et aux blocs enfants, à partir de l’endroit où elle est déclarée:

fn main() {
    let x = 5;  // x_1

    let x = x + 1; // x_2 = x_1 + 1

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

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

On peut changer le type d’une variable:

fn main() {
    let spaces = "   ";
    let spaces = spaces.len();
    println!("{} spaces", spaces);
}

On ne peut pas changer le type d’une variable mutable:

fn main() {
    let mut spaces = "   ";
    // spaces = spaces.len(); // faux !
    println!("{} spaces", spaces);
}

Constantes

Une constante est déclarée avec le mot-clef const et doit être typée. La valeur d’une constante doit être calculable au moment de la compilation du code. La portée d’une constante est identique à celle d’une variable.

const SECONDS_IN_ONE_HOUR: u32 = 60 * 60;
const THREE_HOURS_IN_SECONDS: u32 = SECONDS_IN_ONE_HOUR * 3;

fn main() {
    println!("There are {} seconds in 3 hours.", THREE_HOURS_IN_SECONDS);
}