Salt la conținutul principal
Modulul 1 · Lecția 1 din 21/14 în curs~10 min
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:

Rust
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:

Rust
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ă:

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

Spre deosebire de mut, umbrirea vă permite să:

  1. Schimbați tipul de date al unei variabile păstrând același nume.
  2. Mentineti imuabilitatea variabilei dupa transformari.
Rust
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ă:

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

Acest 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

Exercițiu#rust.m1.l1.e1
Încercări: 0Se încarcă…

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.

Se încarcă editorul...
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

Exercițiu#rust.m1.l1.e2
Încercări: 0Se încarcă…

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!.

Se încarcă editorul...
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

Exercițiu#rust.m1.l1.e3
Încercări: 0Se încarcă…

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.

Se încarcă editorul...
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