Potrivirea modelului, Opțiunea și Rezultatul

Rust are un mecanism de control al fluxului extrem de puternic numit potrivire de model. Vă permite să comparați o valoare cu o serie de modele și să executați cod pe baza modelului care se potrivește.

Declarația match

Declarația match din Rust este similară cu switch în alte limbi, dar mult mai puternică și mai sigură. Compilatorul se asigură că potrivirea este exhaustivă, ceea ce înseamnă că toate cazurile posibile trebuie tratate:

enum Direction {
    North,
    South,
    East,
    West,
}

let dir = Direction::East;

match dir {
    Direction::North => println!("Andiamo a Nord"),
    Direction::South => println!("Andiamo a Sud"),
    Direction::East => println!("Andiamo a Est"),
    Direction::West => println!("Andiamo a Ovest"),
}

Gestionarea absenței valorii: Option

Rugina nu are conceptul de valoare nulă (null sau nil). În schimb, biblioteca standard definește o enumerare numită Option<T> care poate conține:

• Some(T): conține o valoare de tip T.
• None: indică absența valorii.

let x: Option<i32> = Some(5);
let y: Option<i32> = None;

match x {
    Some(val) => println!("C'e un valore: {}", val),
    None => println!("Nessun valore trovato"),
}

Gestionarea erorilor recuperabile: Result

Pentru operațiunile care pot eșua (cum ar fi citirea unui fișier sau analizarea unui șir într-un număr), Rust utilizează enumerarea Result<T, E>, care are două variante:

• Ok(T): operația a reușit și conține valoarea de succes T.
• Err(E): operațiunea a eșuat și conține eroarea E.

fn divide(numerator: f64, denominator: f64) -> Result<f64, String> {
    if denominator == 0.0 {
        Err(String::from("Divisione per zero!"))
    } else {
        Ok(numerator / denominator)
    }
}

Datorită compilatorului lui Rust, sunteți forțat să gestionați cazul Err înainte de a putea accesa valoarea din interiorul Ok, prevenind multe erori comune de rulare.

Modelul Wildcard _

Când lucrați cu tipuri de date care au un număr mare de variante (cum ar fi numere întregi), listarea tuturor cazurilor într-un match este imposibilă. Rust permite utilizarea caracterului wildcard _ pentru a prinde toate cazurile rămase nedefinite în mod explicit:

let some_u8 = 3u8;
match some_u8 {
    1 => println!("One"),
    2 => println!("Two"),
    _ => println!("Something else"), // Handles all other values
}

Încercați-l singur