Lecții din modul (1/2)
Variabile și mutabilitate
În Rust, gestionarea variabilelor și a memoriei este ghidată de două principii fundamentale: siguranță și control. Din acest motiv, spre deosebire de multe alte limbaje de programare, variabilele din Rust sunt imuabile în mod implicit.
Aceasta înseamnă că, odată ce o valoare este atribuită unei variabile, aceasta nu poate fi modificată. Dacă încercați să îl modificați, compilatorul va genera o eroare.
Variabile imuabile și cuvântul cheie mut
Pentru a declara o variabilă, folosim cuvântul cheie let:
let x = 5; // Immutable by default
// x = 6; // ERROR! The compiler will refuse to build this code.Dacă trebuie să modificați valoarea unei variabile, trebuie să o faceți mutabilă în mod explicit utilizând cuvântul cheie mut imediat după let:
let mut y = 10; // Mutable
println!("Il valore di y e: {}", y);
y = 15; // Valid!
println!("Il valore modificato di y e: {}", y);Utilizarea prefixului mut comunică în mod clar compilatorului și oricui citește codul că valoarea se va schimba în timpul execuției.
Umbrirea
Rust permite, de asemenea, conceptul de shadowing, care este re-declararea unei variabile cu același nume folosind din nou cuvântul cheie let. Noua variabilă „umbră” (sau o acoperă) pe cea anterioară:
let x = 5;
let x = x + 1; // Shadowing: x is now 6
let x = x * 2; // Shadowing: x is now 12Spre deosebire de mut, umbrirea vă permite să:
- Schimbați tipul de date al unei variabile păstrând același nume.
- Mentineti imuabilitatea variabilei dupa transformari.
let spaces = " "; // Type: &str (string)
let spaces = spaces.len(); // Type: usize (number)Utilitatea umbrelor și scopurilor
Umbrirea nu se limitează la același bloc; poate fi folosit în blocuri imbricate ({}) pentru a suprascrie temporar o valoare. Când blocul interior se termină, variabila originală devine din nou vizibilă:
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 5Acest mecanism este extrem de sigur și eficient, deoarece are loc în întregime în timpul compilării, asigurând siguranța tipului fără nicio suprasolicitare a performanței de rulare.
Încercați-l singur
Declarați o variabilă mutabilă numită x cu o valoare inițială de 5. Apoi, adăugați 10 la x și imprimați-o pe ecran folosind println! macro.
Afișează indiciu
Declarați variabila cu `let mut x = 5;`, apoi incrementați-o cu `x += 10;` (sau `x = x + 10;`) și în final tipăriți-o cu `println!('{}', x);`.
Soluție disponibilă după 3 încercări
Declarați o variabilă imuabilă y cu o valoare de 10. Umbriți y declarând-o din nou cu let pentru a înmulți valoarea anterioară cu 2 și, în final, tipăriți-o folosind println!.
Afișează indiciu
Use `let y = 10;`, then shadow it by declaring it again with `let y = y * 2;` and finally use `println!` to display it.
Soluție disponibilă după 3 încercări
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.
Afișează indiciu
Declare `let input = "42";`, then shadow it with `let input: i32 = input.parse().unwrap();` and print it using `println!("{}", input);`.
Soluție disponibilă după 3 încercări