Direct naar de hoofdinhoud
Module 1 · Les 1 van 21/14 in de cursus~10 min
Modulelessen (1/2)

Variabelen en veranderlijkheid

In Rust wordt het beheer van variabelen en geheugen geleid door twee fundamentele principes: veiligheid en controle. Om deze reden zijn variabelen in Rust, in tegenstelling tot veel andere programmeertalen, standaard onveranderlijk.

Dit betekent dat zodra een waarde aan een variabele is toegewezen, deze niet meer kan worden gewijzigd. Als u probeert het te wijzigen, zal de compiler een foutmelding geven.

Onveranderlijke variabelen en het trefwoord mut

Om een ​​variabele te declareren, gebruiken we het trefwoord let:

Rust
let x = 5; // Immutable by default
// x = 6; // ERROR! The compiler will refuse to build this code.

Als u de waarde van een variabele moet wijzigen, moet u deze expliciet veranderlijk maken door het trefwoord mut direct na let te gebruiken:

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

Door het voorvoegsel mut te gebruiken, wordt aan de compiler en aan iedereen die de code leest duidelijk gecommuniceerd dat de waarde tijdens de uitvoering zal veranderen.

Schaduwen

Rust maakt ook het concept van shadowing mogelijk, wat het opnieuw declareren van een variabele met dezelfde naam is door opnieuw het trefwoord let te gebruiken. De nieuwe variabele "schaduwt" (of bedekt) de vorige:

Rust
let x = 5;
let x = x + 1; // Shadowing: x is now 6
let x = x * 2; // Shadowing: x is now 12

In tegenstelling tot mut kunt u met schaduwen het volgende doen:

  1. Wijzig het gegevenstype van een variabele met behoud van dezelfde naam.
  2. Behoud de onveranderlijkheid van de variabele na de transformaties.
Rust
let spaces = "   "; // Type: &str (string)
let spaces = spaces.len(); // Type: usize (number)

Nut van schaduwen en scopes

Schaduwvorming is niet beperkt tot hetzelfde blok; het kan worden gebruikt binnen geneste blokken ({}) om tijdelijk een waarde te overschrijven. Wanneer het binnenste blok eindigt, wordt de oorspronkelijke variabele weer zichtbaar:

Rust
let x = 5;
{
    let x = x * 2; // Shadowing valid only inside the block
    println!("Value in the inner block: {}", x); // Prints 10
}
println!("Value in the outer block: {}", x); // Prints 5

Dit mechanisme is uiterst veilig en efficiënt omdat het volledig tijdens het compileren plaatsvindt, waardoor de typeveiligheid wordt gegarandeerd zonder enige runtime-prestatieoverhead.

Probeer het zelf

Oefening#rust.m1.l1.e1
Pogingen: 0Laden…

Declareer een veranderlijke variabele genaamd x met een initiële waarde van 5. Voeg vervolgens 10 toe aan x en druk deze af op het scherm met behulp van println! macro.

Editor laden…
Toon hint

Declareer de variabele met `let mut x = 5;`, verhoog hem vervolgens met `x += 10;` (of `x = x + 10;`) en druk hem ten slotte af met `println!('{}', x);`.

Oplossing beschikbaar na 3 pogingen

Oefening#rust.m1.l1.e2
Pogingen: 0Laden…

Declareer een onveranderlijke variabele y met een waarde van 10. Schaduw y door deze opnieuw te declareren met let om de vorige waarde met 2 te vermenigvuldigen, en druk deze ten slotte af met println!.

Editor laden…
Toon hint

Use `let y = 10;`, then shadow it by declaring it again with `let y = y * 2;` and finally use `println!` to display it.

Oplossing beschikbaar na 3 pogingen

Oefening#rust.m1.l1.e3
Pogingen: 0Laden…

Declare an immutable variable named input containing the string value "42". Shadow input by declaring it as an integer of type i32, converting the original value via input.parse::<i32>().unwrap(). Finally, print it using the println! macro.

Editor laden…
Toon hint

Declare `let input = "42";`, then shadow it with `let input: i32 = input.parse().unwrap();` and print it using `println!("{}", input);`.

Oplossing beschikbaar na 3 pogingen